diff --git "a/parse/train/HyAddcLge/HyAddcLge_middle.json" "b/parse/train/HyAddcLge/HyAddcLge_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/HyAddcLge/HyAddcLge_middle.json" @@ -0,0 +1,34353 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 106, + 79, + 462, + 96 + ], + "lines": [ + { + "bbox": [ + 105, + 78, + 464, + 98 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 464, + 98 + ], + "score": 1.0, + "content": "REVISITING DISTRIBUTED SYNCHRONOUS SGD", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 113, + 114, + 381, + 160 + ], + "lines": [ + { + "bbox": [ + 112, + 114, + 359, + 128 + ], + "spans": [ + { + "bbox": [ + 112, + 114, + 359, + 128 + ], + "score": 1.0, + "content": "Jianmin Chen∗, Xinghao Pan∗†, Rajat Monga, Samy Bengio", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 113, + 127, + 169, + 138 + ], + "spans": [ + { + "bbox": [ + 113, + 127, + 169, + 138 + ], + "score": 1.0, + "content": "Google Brain", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 111, + 137, + 220, + 149 + ], + "spans": [ + { + "bbox": [ + 111, + 137, + 220, + 149 + ], + "score": 1.0, + "content": "Mountain View, CA, USA", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 113, + 149, + 382, + 161 + ], + "spans": [ + { + "bbox": [ + 113, + 149, + 382, + 161 + ], + "score": 1.0, + "content": "{jmchen,xinghao,rajatmonga,bengio}@google.com", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 4.0 + }, + { + "type": "text", + "bbox": [ + 394, + 115, + 495, + 159 + ], + "lines": [ + { + "bbox": [ + 393, + 114, + 468, + 128 + ], + "spans": [ + { + "bbox": [ + 393, + 114, + 468, + 128 + ], + "score": 1.0, + "content": "Rafal Jozefowicz", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 393, + 126, + 430, + 138 + ], + "spans": [ + { + "bbox": [ + 393, + 126, + 430, + 138 + ], + "score": 1.0, + "content": "OpenAI", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 393, + 137, + 496, + 148 + ], + "spans": [ + { + "bbox": [ + 393, + 137, + 496, + 148 + ], + "score": 1.0, + "content": "San Francisco, CA, USA", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 393, + 148, + 492, + 160 + ], + "spans": [ + { + "bbox": [ + 393, + 148, + 492, + 160 + ], + "score": 1.0, + "content": "rafal@openai.com", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.0 + }, + { + "type": "title", + "bbox": [ + 278, + 189, + 333, + 200 + ], + "lines": [ + { + "bbox": [ + 276, + 188, + 335, + 201 + ], + "spans": [ + { + "bbox": [ + 276, + 188, + 335, + 201 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 143, + 214, + 468, + 313 + ], + "lines": [ + { + "bbox": [ + 141, + 213, + 469, + 227 + ], + "spans": [ + { + "bbox": [ + 141, + 213, + 469, + 227 + ], + "score": 1.0, + "content": "Distributed training of deep learning models on large-scale training data is typi-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 225, + 470, + 237 + ], + "spans": [ + { + "bbox": [ + 141, + 225, + 470, + 237 + ], + "score": 1.0, + "content": "cally conducted with asynchronous stochastic optimization to maximize the rate", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 142, + 236, + 469, + 248 + ], + "spans": [ + { + "bbox": [ + 142, + 236, + 469, + 248 + ], + "score": 1.0, + "content": "of updates, at the cost of additional noise introduced from asynchrony. In con-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 247, + 470, + 258 + ], + "spans": [ + { + "bbox": [ + 141, + 247, + 470, + 258 + ], + "score": 1.0, + "content": "trast, the synchronous approach is often thought to be impractical due to idle time", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 258, + 470, + 270 + ], + "spans": [ + { + "bbox": [ + 141, + 258, + 470, + 270 + ], + "score": 1.0, + "content": "wasted on waiting for straggling workers. We revisit these conventional beliefs", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 268, + 470, + 281 + ], + "spans": [ + { + "bbox": [ + 141, + 268, + 470, + 281 + ], + "score": 1.0, + "content": "in this paper, and examine the weaknesses of both approaches. We demonstrate", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 279, + 470, + 293 + ], + "spans": [ + { + "bbox": [ + 141, + 279, + 470, + 293 + ], + "score": 1.0, + "content": "that a third approach, synchronous optimization with backup workers, can avoid", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 291, + 470, + 304 + ], + "spans": [ + { + "bbox": [ + 141, + 291, + 470, + 304 + ], + "score": 1.0, + "content": "asynchronous noise while mitigating for the worst stragglers. Our approach is", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 302, + 464, + 314 + ], + "spans": [ + { + "bbox": [ + 141, + 302, + 464, + 314 + ], + "score": 1.0, + "content": "empirically validated and shown to converge faster and to better test accuracies.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14 + }, + { + "type": "title", + "bbox": [ + 108, + 335, + 206, + 347 + ], + "lines": [ + { + "bbox": [ + 105, + 334, + 208, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 208, + 351 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 360, + 505, + 437 + ], + "lines": [ + { + "bbox": [ + 105, + 359, + 505, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 505, + 374 + ], + "score": 1.0, + "content": "The recent success of deep learning approaches for domains like speech recognition (Hinton et al.,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 371, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 505, + 384 + ], + "score": 1.0, + "content": "2012) and computer vision (Ioffe & Szegedy, 2015) stems from many algorithmic improvements", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 381, + 505, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 505, + 395 + ], + "score": 1.0, + "content": "but also from the fact that the size of available training data has grown significantly over the years,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 393, + 505, + 406 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 505, + 406 + ], + "score": 1.0, + "content": "together with the computing power, in terms of both CPUs and GPUs. While a single GPU often", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "score": 1.0, + "content": "provides algorithmic simplicity and speed up to a given scale of data and model, there exist an", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 415, + 506, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 506, + 428 + ], + "score": 1.0, + "content": "operating point where a distributed implementation of training algorithms for deep architectures", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 426, + 187, + 439 + ], + "spans": [ + { + "bbox": [ + 106, + 426, + 187, + 439 + ], + "score": 1.0, + "content": "becomes necessary.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 443, + 505, + 531 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 505, + 456 + ], + "score": 1.0, + "content": "Currently, popular distributed training algorithms include mini-batch versions of stochastic gradient", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 454, + 505, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 505, + 466 + ], + "score": 1.0, + "content": "descent (SGD) and other stochastic optimization algorithms such as AdaGrad (Duchi et al., 2011),", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 464, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 505, + 478 + ], + "score": 1.0, + "content": "RMSProp (Tieleman & Hinton, 2012), and ADAM (Kingma & Ba, 2014). Unfortunately, bulk-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 476, + 505, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 476, + 505, + 488 + ], + "score": 1.0, + "content": "synchronous implementations of stochastic optimization are often slow in practice due to the need", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 487, + 505, + 499 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 505, + 499 + ], + "score": 1.0, + "content": "to wait for the slowest machine in each synchronous batch. To circumvent this problem, practi-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 497, + 506, + 511 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 506, + 511 + ], + "score": 1.0, + "content": "tioners have resorted to asynchronous approaches which emphasize speed by using potentially stale", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 508, + 505, + 521 + ], + "spans": [ + { + "bbox": [ + 105, + 508, + 505, + 521 + ], + "score": 1.0, + "content": "information for computation. While asynchronous training have proven to be faster than their syn-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 520, + 399, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 520, + 399, + 532 + ], + "score": 1.0, + "content": "chronous counterparts, they often result in convergence to poorer results.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 30.5 + }, + { + "type": "text", + "bbox": [ + 108, + 536, + 504, + 581 + ], + "lines": [ + { + "bbox": [ + 105, + 536, + 506, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 506, + 550 + ], + "score": 1.0, + "content": "In this paper1, we revisit synchronous learning, and propose a method for mitigating stragglers in", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 547, + 506, + 560 + ], + "spans": [ + { + "bbox": [ + 106, + 547, + 506, + 560 + ], + "score": 1.0, + "content": "synchronous stochastic optimization. Specifically, we synchronously compute a mini-batch gradient", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 558, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 505, + 572 + ], + "score": 1.0, + "content": "with only a subset of worker machines, thus alleviating the straggler effect while avoiding any", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 570, + 388, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 570, + 388, + 582 + ], + "score": 1.0, + "content": "staleness in our gradients. The primary contributions of our paper are:", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 132, + 590, + 505, + 691 + ], + "lines": [ + { + "bbox": [ + 132, + 590, + 504, + 603 + ], + "spans": [ + { + "bbox": [ + 132, + 590, + 504, + 603 + ], + "score": 1.0, + "content": "• Illustration of how gradient staleness in asynchronous training negatively impacts test ac-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 141, + 601, + 315, + 613 + ], + "spans": [ + { + "bbox": [ + 141, + 601, + 315, + 613 + ], + "score": 1.0, + "content": "curacy and is exacerbated by deep models.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 137, + 615, + 506, + 630 + ], + "spans": [ + { + "bbox": [ + 137, + 615, + 506, + 630 + ], + "score": 1.0, + "content": "Measurement of machine response times for synchronous stochastic optimization in a large", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 141, + 628, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 141, + 628, + 505, + 641 + ], + "score": 1.0, + "content": "deployment of 100 GPUs, showing how stragglers in the tail end affect convergence speed.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 140, + 642, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 140, + 642, + 505, + 656 + ], + "score": 1.0, + "content": "Proposal of synchronous stochastic optimization with backup workers to mitigate straggler", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 141, + 653, + 279, + 667 + ], + "spans": [ + { + "bbox": [ + 141, + 653, + 279, + 667 + ], + "score": 1.0, + "content": "effects without gradient staleness.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 131, + 668, + 505, + 682 + ], + "spans": [ + { + "bbox": [ + 131, + 668, + 505, + 682 + ], + "score": 1.0, + "content": "• Establishing the need to measure both speed of convergence and test accuracy of optimum", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 141, + 680, + 241, + 693 + ], + "spans": [ + { + "bbox": [ + 141, + 680, + 241, + 693 + ], + "score": 1.0, + "content": "for empirical validation.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 42.5 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 119, + 700, + 436, + 732 + ], + "lines": [ + { + "bbox": [ + 118, + 698, + 188, + 710 + ], + "spans": [ + { + "bbox": [ + 118, + 698, + 188, + 710 + ], + "score": 1.0, + "content": "∗Joint first authors", + "type": "text" + } + ] + }, + { + "bbox": [ + 118, + 708, + 386, + 723 + ], + "spans": [ + { + "bbox": [ + 118, + 708, + 386, + 723 + ], + "score": 1.0, + "content": "†UC Berkeley, Berkeley, CA, USA, xinghao@eecs.berkeley.edu", + "type": "text" + } + ] + }, + { + "bbox": [ + 118, + 719, + 437, + 733 + ], + "spans": [ + { + "bbox": [ + 118, + 719, + 437, + 733 + ], + "score": 1.0, + "content": "1This is an extension of our ICLR 2016 workshop extended abstract (Chen et al., 2016).", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "1", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 106, + 79, + 462, + 96 + ], + "lines": [ + { + "bbox": [ + 105, + 78, + 464, + 98 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 464, + 98 + ], + "score": 1.0, + "content": "REVISITING DISTRIBUTED SYNCHRONOUS SGD", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "list", + "bbox": [ + 113, + 114, + 381, + 160 + ], + "lines": [ + { + "bbox": [ + 112, + 114, + 359, + 128 + ], + "spans": [ + { + "bbox": [ + 112, + 114, + 359, + 128 + ], + "score": 1.0, + "content": "Jianmin Chen∗, Xinghao Pan∗†, Rajat Monga, Samy Bengio", + "type": "text" + } + ], + "index": 1, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 127, + 169, + 138 + ], + "spans": [ + { + "bbox": [ + 113, + 127, + 169, + 138 + ], + "score": 1.0, + "content": "Google Brain", + "type": "text" + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 111, + 137, + 220, + 149 + ], + "spans": [ + { + "bbox": [ + 111, + 137, + 220, + 149 + ], + "score": 1.0, + "content": "Mountain View, CA, USA", + "type": "text" + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 149, + 382, + 161 + ], + "spans": [ + { + "bbox": [ + 113, + 149, + 382, + 161 + ], + "score": 1.0, + "content": "{jmchen,xinghao,rajatmonga,bengio}@google.com", + "type": "text" + } + ], + "index": 7, + "is_list_start_line": true + } + ], + "index": 4.0, + "bbox_fs": [ + 111, + 114, + 382, + 161 + ] + }, + { + "type": "text", + "bbox": [ + 394, + 115, + 495, + 159 + ], + "lines": [ + { + "bbox": [ + 393, + 114, + 468, + 128 + ], + "spans": [ + { + "bbox": [ + 393, + 114, + 468, + 128 + ], + "score": 1.0, + "content": "Rafal Jozefowicz", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 393, + 126, + 430, + 138 + ], + "spans": [ + { + "bbox": [ + 393, + 126, + 430, + 138 + ], + "score": 1.0, + "content": "OpenAI", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 393, + 137, + 496, + 148 + ], + "spans": [ + { + "bbox": [ + 393, + 137, + 496, + 148 + ], + "score": 1.0, + "content": "San Francisco, CA, USA", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 393, + 148, + 492, + 160 + ], + "spans": [ + { + "bbox": [ + 393, + 148, + 492, + 160 + ], + "score": 1.0, + "content": "rafal@openai.com", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.0, + "bbox_fs": [ + 393, + 114, + 496, + 160 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 189, + 333, + 200 + ], + "lines": [ + { + "bbox": [ + 276, + 188, + 335, + 201 + ], + "spans": [ + { + "bbox": [ + 276, + 188, + 335, + 201 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 143, + 214, + 468, + 313 + ], + "lines": [ + { + "bbox": [ + 141, + 213, + 469, + 227 + ], + "spans": [ + { + "bbox": [ + 141, + 213, + 469, + 227 + ], + "score": 1.0, + "content": "Distributed training of deep learning models on large-scale training data is typi-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 225, + 470, + 237 + ], + "spans": [ + { + "bbox": [ + 141, + 225, + 470, + 237 + ], + "score": 1.0, + "content": "cally conducted with asynchronous stochastic optimization to maximize the rate", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 142, + 236, + 469, + 248 + ], + "spans": [ + { + "bbox": [ + 142, + 236, + 469, + 248 + ], + "score": 1.0, + "content": "of updates, at the cost of additional noise introduced from asynchrony. In con-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 247, + 470, + 258 + ], + "spans": [ + { + "bbox": [ + 141, + 247, + 470, + 258 + ], + "score": 1.0, + "content": "trast, the synchronous approach is often thought to be impractical due to idle time", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 258, + 470, + 270 + ], + "spans": [ + { + "bbox": [ + 141, + 258, + 470, + 270 + ], + "score": 1.0, + "content": "wasted on waiting for straggling workers. We revisit these conventional beliefs", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 268, + 470, + 281 + ], + "spans": [ + { + "bbox": [ + 141, + 268, + 470, + 281 + ], + "score": 1.0, + "content": "in this paper, and examine the weaknesses of both approaches. We demonstrate", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 279, + 470, + 293 + ], + "spans": [ + { + "bbox": [ + 141, + 279, + 470, + 293 + ], + "score": 1.0, + "content": "that a third approach, synchronous optimization with backup workers, can avoid", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 291, + 470, + 304 + ], + "spans": [ + { + "bbox": [ + 141, + 291, + 470, + 304 + ], + "score": 1.0, + "content": "asynchronous noise while mitigating for the worst stragglers. Our approach is", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 302, + 464, + 314 + ], + "spans": [ + { + "bbox": [ + 141, + 302, + 464, + 314 + ], + "score": 1.0, + "content": "empirically validated and shown to converge faster and to better test accuracies.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14, + "bbox_fs": [ + 141, + 213, + 470, + 314 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 335, + 206, + 347 + ], + "lines": [ + { + "bbox": [ + 105, + 334, + 208, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 208, + 351 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 360, + 505, + 437 + ], + "lines": [ + { + "bbox": [ + 105, + 359, + 505, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 505, + 374 + ], + "score": 1.0, + "content": "The recent success of deep learning approaches for domains like speech recognition (Hinton et al.,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 371, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 505, + 384 + ], + "score": 1.0, + "content": "2012) and computer vision (Ioffe & Szegedy, 2015) stems from many algorithmic improvements", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 381, + 505, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 505, + 395 + ], + "score": 1.0, + "content": "but also from the fact that the size of available training data has grown significantly over the years,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 393, + 505, + 406 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 505, + 406 + ], + "score": 1.0, + "content": "together with the computing power, in terms of both CPUs and GPUs. While a single GPU often", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "score": 1.0, + "content": "provides algorithmic simplicity and speed up to a given scale of data and model, there exist an", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 415, + 506, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 506, + 428 + ], + "score": 1.0, + "content": "operating point where a distributed implementation of training algorithms for deep architectures", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 426, + 187, + 439 + ], + "spans": [ + { + "bbox": [ + 106, + 426, + 187, + 439 + ], + "score": 1.0, + "content": "becomes necessary.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 359, + 506, + 439 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 443, + 505, + 531 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 505, + 456 + ], + "score": 1.0, + "content": "Currently, popular distributed training algorithms include mini-batch versions of stochastic gradient", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 454, + 505, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 505, + 466 + ], + "score": 1.0, + "content": "descent (SGD) and other stochastic optimization algorithms such as AdaGrad (Duchi et al., 2011),", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 464, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 505, + 478 + ], + "score": 1.0, + "content": "RMSProp (Tieleman & Hinton, 2012), and ADAM (Kingma & Ba, 2014). Unfortunately, bulk-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 476, + 505, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 476, + 505, + 488 + ], + "score": 1.0, + "content": "synchronous implementations of stochastic optimization are often slow in practice due to the need", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 487, + 505, + 499 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 505, + 499 + ], + "score": 1.0, + "content": "to wait for the slowest machine in each synchronous batch. To circumvent this problem, practi-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 497, + 506, + 511 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 506, + 511 + ], + "score": 1.0, + "content": "tioners have resorted to asynchronous approaches which emphasize speed by using potentially stale", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 508, + 505, + 521 + ], + "spans": [ + { + "bbox": [ + 105, + 508, + 505, + 521 + ], + "score": 1.0, + "content": "information for computation. While asynchronous training have proven to be faster than their syn-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 520, + 399, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 520, + 399, + 532 + ], + "score": 1.0, + "content": "chronous counterparts, they often result in convergence to poorer results.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 442, + 506, + 532 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 536, + 504, + 581 + ], + "lines": [ + { + "bbox": [ + 105, + 536, + 506, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 506, + 550 + ], + "score": 1.0, + "content": "In this paper1, we revisit synchronous learning, and propose a method for mitigating stragglers in", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 547, + 506, + 560 + ], + "spans": [ + { + "bbox": [ + 106, + 547, + 506, + 560 + ], + "score": 1.0, + "content": "synchronous stochastic optimization. Specifically, we synchronously compute a mini-batch gradient", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 558, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 505, + 572 + ], + "score": 1.0, + "content": "with only a subset of worker machines, thus alleviating the straggler effect while avoiding any", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 570, + 388, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 570, + 388, + 582 + ], + "score": 1.0, + "content": "staleness in our gradients. The primary contributions of our paper are:", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 536, + 506, + 582 + ] + }, + { + "type": "list", + "bbox": [ + 132, + 590, + 505, + 691 + ], + "lines": [ + { + "bbox": [ + 132, + 590, + 504, + 603 + ], + "spans": [ + { + "bbox": [ + 132, + 590, + 504, + 603 + ], + "score": 1.0, + "content": "• Illustration of how gradient staleness in asynchronous training negatively impacts test ac-", + "type": "text" + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 601, + 315, + 613 + ], + "spans": [ + { + "bbox": [ + 141, + 601, + 315, + 613 + ], + "score": 1.0, + "content": "curacy and is exacerbated by deep models.", + "type": "text" + } + ], + "index": 40, + "is_list_end_line": true + }, + { + "bbox": [ + 137, + 615, + 506, + 630 + ], + "spans": [ + { + "bbox": [ + 137, + 615, + 506, + 630 + ], + "score": 1.0, + "content": "Measurement of machine response times for synchronous stochastic optimization in a large", + "type": "text" + } + ], + "index": 41, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 628, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 141, + 628, + 505, + 641 + ], + "score": 1.0, + "content": "deployment of 100 GPUs, showing how stragglers in the tail end affect convergence speed.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 140, + 642, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 140, + 642, + 505, + 656 + ], + "score": 1.0, + "content": "Proposal of synchronous stochastic optimization with backup workers to mitigate straggler", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 141, + 653, + 279, + 667 + ], + "spans": [ + { + "bbox": [ + 141, + 653, + 279, + 667 + ], + "score": 1.0, + "content": "effects without gradient staleness.", + "type": "text" + } + ], + "index": 44, + "is_list_end_line": true + }, + { + "bbox": [ + 131, + 668, + 505, + 682 + ], + "spans": [ + { + "bbox": [ + 131, + 668, + 505, + 682 + ], + "score": 1.0, + "content": "• Establishing the need to measure both speed of convergence and test accuracy of optimum", + "type": "text" + } + ], + "index": 45, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 680, + 241, + 693 + ], + "spans": [ + { + "bbox": [ + 141, + 680, + 241, + 693 + ], + "score": 1.0, + "content": "for empirical validation.", + "type": "text" + } + ], + "index": 46, + "is_list_end_line": true + } + ], + "index": 42.5, + "bbox_fs": [ + 131, + 590, + 506, + 693 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 128, + 82, + 503, + 105 + ], + "lines": [ + { + "bbox": [ + 132, + 82, + 504, + 96 + ], + "spans": [ + { + "bbox": [ + 132, + 82, + 504, + 96 + ], + "score": 1.0, + "content": "• Empirical demonstration that our proposed synchronous training method outperforms asyn-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 142, + 94, + 412, + 106 + ], + "spans": [ + { + "bbox": [ + 142, + 94, + 412, + 106 + ], + "score": 1.0, + "content": "chronous training by converging faster and to better test accuracies.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 107, + 113, + 505, + 169 + ], + "lines": [ + { + "bbox": [ + 105, + 113, + 505, + 126 + ], + "spans": [ + { + "bbox": [ + 105, + 113, + 505, + 126 + ], + "score": 1.0, + "content": "The remainder of this paper is organized as follows. We briefly present preliminaries and notation", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 123, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 123, + 505, + 138 + ], + "score": 1.0, + "content": "in Section 1.1. Section 2 describes asynchronous stochastic optimization and presents experimental", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 136, + 505, + 149 + ], + "spans": [ + { + "bbox": [ + 105, + 136, + 505, + 149 + ], + "score": 1.0, + "content": "evidence of gradient staleness in deep neural network models. We present our approach in Section 3,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 147, + 505, + 159 + ], + "spans": [ + { + "bbox": [ + 106, + 147, + 505, + 159 + ], + "score": 1.0, + "content": "and exhibit straggler effects that motivate the approach. We then empirically evaluate our approach", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 157, + 443, + 170 + ], + "spans": [ + { + "bbox": [ + 105, + 157, + 443, + 170 + ], + "score": 1.0, + "content": "in Sections 4. Related work is discussed in Section 5, and we conclude in Section 6.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4 + }, + { + "type": "title", + "bbox": [ + 108, + 182, + 268, + 194 + ], + "lines": [ + { + "bbox": [ + 106, + 181, + 269, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 181, + 269, + 195 + ], + "score": 1.0, + "content": "1.1 PRELIMINARIES AND NOTATION", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 202, + 505, + 242 + ], + "lines": [ + { + "bbox": [ + 105, + 201, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 201, + 171, + 216 + ], + "score": 1.0, + "content": "Given a dataset", + "type": "text" + }, + { + "bbox": [ + 172, + 203, + 285, + 215 + ], + "score": 0.92, + "content": "\\mathcal { X } = \\{ x _ { i } : i = 1 , \\ldots , | \\mathcal { X } | \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 201, + 430, + 216 + ], + "score": 1.0, + "content": ", our goal is to learn the parameters", + "type": "text" + }, + { + "bbox": [ + 430, + 203, + 437, + 213 + ], + "score": 0.82, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 201, + 505, + 216 + ], + "score": 1.0, + "content": "of a model with", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 101, + 210, + 509, + 237 + ], + "spans": [ + { + "bbox": [ + 101, + 210, + 253, + 237 + ], + "score": 1.0, + "content": "respect to an empirical loss function", + "type": "text" + }, + { + "bbox": [ + 253, + 218, + 260, + 230 + ], + "score": 0.82, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 261, + 210, + 306, + 237 + ], + "score": 1.0, + "content": ", defined as", + "type": "text" + }, + { + "bbox": [ + 307, + 214, + 415, + 232 + ], + "score": 0.94, + "content": "\\begin{array} { r } { f ( \\theta ) \\stackrel { \\Delta } { = } \\frac { 1 } { | \\mathcal { X } | } \\sum _ { i = 1 } ^ { | \\mathcal { X } | } F ( x _ { i } ; \\theta ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 210, + 445, + 237 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 445, + 217, + 480, + 230 + ], + "score": 0.93, + "content": "F ( x _ { i } ; \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 480, + 210, + 509, + 237 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 230, + 313, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 230, + 232, + 244 + ], + "score": 1.0, + "content": "loss with respect to a datapoint", + "type": "text" + }, + { + "bbox": [ + 232, + 232, + 243, + 242 + ], + "score": 0.85, + "content": "x _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 230, + 302, + 244 + ], + "score": 1.0, + "content": "and the model", + "type": "text" + }, + { + "bbox": [ + 303, + 231, + 309, + 241 + ], + "score": 0.78, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 230, + 313, + 244 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 106, + 247, + 505, + 349 + ], + "lines": [ + { + "bbox": [ + 105, + 246, + 506, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 462, + 261 + ], + "score": 1.0, + "content": "A first-order stochastic optimization algorithm achieves this by iteratively updating", + "type": "text" + }, + { + "bbox": [ + 462, + 248, + 469, + 258 + ], + "score": 0.76, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 469, + 246, + 506, + 261 + ], + "score": 1.0, + "content": "using a", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 104, + 259, + 506, + 277 + ], + "spans": [ + { + "bbox": [ + 104, + 259, + 186, + 277 + ], + "score": 1.0, + "content": "stochastic gradient", + "type": "text" + }, + { + "bbox": [ + 186, + 259, + 255, + 275 + ], + "score": 0.93, + "content": "G \\overset { \\Delta } { = } \\nabla F ( x _ { i } ; \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 259, + 398, + 277 + ], + "score": 1.0, + "content": "computed at a randomly sampled", + "type": "text" + }, + { + "bbox": [ + 398, + 264, + 408, + 273 + ], + "score": 0.82, + "content": "x _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 259, + 506, + 277 + ], + "score": 1.0, + "content": ", producing a sequence", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 104, + 272, + 506, + 288 + ], + "spans": [ + { + "bbox": [ + 104, + 272, + 150, + 288 + ], + "score": 1.0, + "content": "of models", + "type": "text" + }, + { + "bbox": [ + 150, + 273, + 205, + 286 + ], + "score": 0.9, + "content": "\\theta ^ { ( 0 ) } , \\theta ^ { ( 1 ) } , \\ldots", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 272, + 506, + 288 + ], + "score": 1.0, + "content": ". Stochastic optimization algorithms differ in their update equations. For", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 284, + 507, + 300 + ], + "spans": [ + { + "bbox": [ + 104, + 284, + 235, + 300 + ], + "score": 1.0, + "content": "example, the update of SGD is", + "type": "text" + }, + { + "bbox": [ + 235, + 285, + 436, + 298 + ], + "score": 0.89, + "content": "\\bar { \\theta ^ { ( t + 1 ) } } \\bar { \\bf \\Phi } = \\theta ^ { ( t ) } - \\gamma _ { t } \\bar { G } ^ { ( t ) } = \\theta ^ { ( t ) } - \\gamma _ { t } \\nabla F ( x _ { i } ; \\bar { \\theta } ^ { ( t ) } )", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 284, + 468, + 300 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 468, + 288, + 479, + 298 + ], + "score": 0.84, + "content": "\\gamma _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 284, + 507, + 300 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 297, + 504, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 258, + 310 + ], + "score": 1.0, + "content": "learning rate or step size at iteration", + "type": "text" + }, + { + "bbox": [ + 258, + 299, + 263, + 308 + ], + "score": 0.68, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 297, + 504, + 310 + ], + "score": 1.0, + "content": ". A mini-batch version of the stochastic optimization algo-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 104, + 308, + 506, + 322 + ], + "spans": [ + { + "bbox": [ + 104, + 308, + 359, + 322 + ], + "score": 1.0, + "content": "rithm computes the stochastic gradient over mini-batch of size", + "type": "text" + }, + { + "bbox": [ + 359, + 309, + 369, + 318 + ], + "score": 0.82, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 308, + 506, + 322 + ], + "score": 1.0, + "content": "instead of a single datapoint, i.e.,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 320, + 507, + 337 + ], + "spans": [ + { + "bbox": [ + 106, + 320, + 221, + 336 + ], + "score": 0.92, + "content": "\\begin{array} { r } { G \\stackrel { \\Delta } { = } \\frac { 1 } { B } \\sum _ { i = 1 } ^ { B } \\nabla F ( \\widetilde { x } _ { i } ; \\theta ^ { ( t ) } ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 221, + 320, + 254, + 337 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 254, + 323, + 265, + 334 + ], + "score": 0.86, + "content": "\\widetilde { x } _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 320, + 392, + 337 + ], + "score": 1.0, + "content": "’s are randomly sampled from", + "type": "text" + }, + { + "bbox": [ + 392, + 324, + 402, + 333 + ], + "score": 0.78, + "content": "\\mathcal { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 320, + 507, + 337 + ], + "score": 1.0, + "content": ". We will often evaluate", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 334, + 495, + 351 + ], + "spans": [ + { + "bbox": [ + 104, + 334, + 299, + 351 + ], + "score": 1.0, + "content": "performance on an exponential moving average", + "type": "text" + }, + { + "bbox": [ + 299, + 335, + 417, + 349 + ], + "score": 0.92, + "content": "\\bar { \\theta } ^ { ( t ) } = \\alpha \\bar { \\theta } ^ { ( t - 1 ) } + ( 1 - \\alpha ) \\theta ^ { ( t ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 334, + 482, + 351 + ], + "score": 1.0, + "content": "with decay rate", + "type": "text" + }, + { + "bbox": [ + 482, + 339, + 489, + 347 + ], + "score": 0.75, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 490, + 334, + 495, + 351 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14.5 + }, + { + "type": "text", + "bbox": [ + 107, + 353, + 505, + 398 + ], + "lines": [ + { + "bbox": [ + 105, + 353, + 505, + 366 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 338, + 366 + ], + "score": 1.0, + "content": "Our interest is in distributed stochastic optimization using", + "type": "text" + }, + { + "bbox": [ + 339, + 354, + 349, + 363 + ], + "score": 0.81, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 353, + 505, + 366 + ], + "score": 1.0, + "content": "worker machines in charge of comput-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 364, + 505, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 364, + 262, + 377 + ], + "score": 1.0, + "content": "ing stochastic gradients that are sent to", + "type": "text" + }, + { + "bbox": [ + 262, + 365, + 274, + 374 + ], + "score": 0.81, + "content": "M", + "type": "inline_equation" + }, + { + "bbox": [ + 274, + 364, + 441, + 377 + ], + "score": 1.0, + "content": "parameter servers. Each parameter server", + "type": "text" + }, + { + "bbox": [ + 441, + 365, + 447, + 376 + ], + "score": 0.83, + "content": "j", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 364, + 505, + 377 + ], + "score": 1.0, + "content": "is responsible", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 374, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 186, + 389 + ], + "score": 1.0, + "content": "for storing a subset", + "type": "text" + }, + { + "bbox": [ + 187, + 375, + 203, + 387 + ], + "score": 0.9, + "content": "\\theta [ j ]", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 374, + 372, + 389 + ], + "score": 1.0, + "content": "of the model, and performing updates on", + "type": "text" + }, + { + "bbox": [ + 372, + 375, + 388, + 387 + ], + "score": 0.91, + "content": "\\theta [ j ]", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 374, + 505, + 389 + ], + "score": 1.0, + "content": ". In the synchronous setting,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 386, + 409, + 399 + ], + "spans": [ + { + "bbox": [ + 106, + 386, + 240, + 399 + ], + "score": 1.0, + "content": "we will also introduce additional", + "type": "text" + }, + { + "bbox": [ + 240, + 387, + 245, + 396 + ], + "score": 0.53, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 386, + 409, + 399 + ], + "score": 1.0, + "content": "backup workers for straggler mitigation.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5 + }, + { + "type": "title", + "bbox": [ + 107, + 413, + 362, + 426 + ], + "lines": [ + { + "bbox": [ + 104, + 412, + 363, + 428 + ], + "spans": [ + { + "bbox": [ + 104, + 412, + 363, + 428 + ], + "score": 1.0, + "content": "2 ASYNCHRONOUS STOCHASTIC OPTIMIZATION", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 108, + 438, + 505, + 493 + ], + "lines": [ + { + "bbox": [ + 106, + 438, + 504, + 450 + ], + "spans": [ + { + "bbox": [ + 106, + 438, + 504, + 450 + ], + "score": 1.0, + "content": "An approach for a distributed stochastic gradient descent algorithm was presented in Dean et al.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 449, + 505, + 462 + ], + "spans": [ + { + "bbox": [ + 106, + 449, + 505, + 462 + ], + "score": 1.0, + "content": "(2012), consisting of two main ingredients. First, the parameters of the model are distributed on", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 459, + 506, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 506, + 474 + ], + "score": 1.0, + "content": "multiple servers, depending on the architecture. This set of servers are called the parameter servers.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 469, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 505, + 486 + ], + "score": 1.0, + "content": "Second, there can be multiple workers processing data in parallel and communicating with the pa-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 482, + 505, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 505, + 494 + ], + "score": 1.0, + "content": "rameter servers. Each worker processes a mini-batch of data independently of the others, as follows:", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 132, + 502, + 504, + 566 + ], + "lines": [ + { + "bbox": [ + 132, + 502, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 132, + 502, + 505, + 515 + ], + "score": 1.0, + "content": "• The worker fetches from the parameter servers the most up-to-date parameters of the model", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 141, + 513, + 309, + 525 + ], + "spans": [ + { + "bbox": [ + 141, + 513, + 309, + 525 + ], + "score": 1.0, + "content": "needed to process the current mini-batch;", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 132, + 527, + 427, + 541 + ], + "spans": [ + { + "bbox": [ + 132, + 527, + 427, + 541 + ], + "score": 1.0, + "content": "• It then computes gradients of the loss with respect to these parameters;", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 131, + 541, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 131, + 541, + 505, + 555 + ], + "score": 1.0, + "content": "• Finally, these gradients are sent back to the parameter servers, which then updates the", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 141, + 553, + 221, + 567 + ], + "spans": [ + { + "bbox": [ + 141, + 553, + 221, + 567 + ], + "score": 1.0, + "content": "model accordingly.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 574, + 505, + 619 + ], + "lines": [ + { + "bbox": [ + 105, + 573, + 506, + 587 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 506, + 587 + ], + "score": 1.0, + "content": "Since each worker communicates with the parameter servers independently of the others, this is", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 584, + 505, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 505, + 598 + ], + "score": 1.0, + "content": "called Asynchronous Stochastic Gradient Descent (Async-SGD), or more generally, Asynchronous", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 596, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 505, + 609 + ], + "score": 1.0, + "content": "Stochastic Optimization (Async-Opt). A similar approach was later proposed by Chilimbi et al.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 607, + 327, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 327, + 620 + ], + "score": 1.0, + "content": "(2014). Async-Opt is presented in Algorithms 1 and 2.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 106, + 623, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 624, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 505, + 636 + ], + "score": 1.0, + "content": "In practice, the updates of Async-Opt are different than those of serially running the stochastic", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 634, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 634, + 505, + 649 + ], + "score": 1.0, + "content": "optimization algorithm for two reasons. Firstly, the read operation (Algo 1 Line 2) on a worker may", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 104, + 646, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 104, + 646, + 473, + 661 + ], + "score": 1.0, + "content": "be interleaved with updates by other workers to different parameter servers, so the resultant", + "type": "text" + }, + { + "bbox": [ + 473, + 646, + 484, + 659 + ], + "score": 0.9, + "content": "\\widehat { \\theta } _ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 646, + 505, + 661 + ], + "score": 1.0, + "content": "may", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 659, + 506, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 303, + 673 + ], + "score": 1.0, + "content": "not be consistent with any parameter incarnation", + "type": "text" + }, + { + "bbox": [ + 304, + 659, + 319, + 670 + ], + "score": 0.89, + "content": "\\boldsymbol { \\theta } ^ { ( t ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 659, + 506, + 673 + ], + "score": 1.0, + "content": ". Secondly, model updates may have occurred", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "score": 1.0, + "content": "while a worker is computing its stochastic gradient; hence, the resultant gradients are typically", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 682, + 505, + 695 + ], + "spans": [ + { + "bbox": [ + 106, + 682, + 505, + 695 + ], + "score": 1.0, + "content": "computed with respect to outdated parameters. We refer to these as stale gradients, and its staleness", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 693, + 504, + 705 + ], + "spans": [ + { + "bbox": [ + 106, + 693, + 504, + 705 + ], + "score": 1.0, + "content": "as the number of updates that have occurred between its corresponding read and update operations.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 108, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "Understanding the theoretical impact of staleness is difficult work and the topic of many recent", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "papers, e.g. Recht et al. (2011); Duchi et al. (2013); Leblond et al. (2016); Reddi et al. (2015);", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45.5 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "score": 1.0, + "content": "2", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 128, + 82, + 503, + 105 + ], + "lines": [ + { + "bbox": [ + 132, + 82, + 504, + 96 + ], + "spans": [ + { + "bbox": [ + 132, + 82, + 504, + 96 + ], + "score": 1.0, + "content": "• Empirical demonstration that our proposed synchronous training method outperforms asyn-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 142, + 94, + 412, + 106 + ], + "spans": [ + { + "bbox": [ + 142, + 94, + 412, + 106 + ], + "score": 1.0, + "content": "chronous training by converging faster and to better test accuracies.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 132, + 82, + 504, + 106 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 113, + 505, + 169 + ], + "lines": [ + { + "bbox": [ + 105, + 113, + 505, + 126 + ], + "spans": [ + { + "bbox": [ + 105, + 113, + 505, + 126 + ], + "score": 1.0, + "content": "The remainder of this paper is organized as follows. We briefly present preliminaries and notation", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 123, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 123, + 505, + 138 + ], + "score": 1.0, + "content": "in Section 1.1. Section 2 describes asynchronous stochastic optimization and presents experimental", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 136, + 505, + 149 + ], + "spans": [ + { + "bbox": [ + 105, + 136, + 505, + 149 + ], + "score": 1.0, + "content": "evidence of gradient staleness in deep neural network models. We present our approach in Section 3,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 147, + 505, + 159 + ], + "spans": [ + { + "bbox": [ + 106, + 147, + 505, + 159 + ], + "score": 1.0, + "content": "and exhibit straggler effects that motivate the approach. We then empirically evaluate our approach", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 157, + 443, + 170 + ], + "spans": [ + { + "bbox": [ + 105, + 157, + 443, + 170 + ], + "score": 1.0, + "content": "in Sections 4. Related work is discussed in Section 5, and we conclude in Section 6.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4, + "bbox_fs": [ + 105, + 113, + 505, + 170 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 182, + 268, + 194 + ], + "lines": [ + { + "bbox": [ + 106, + 181, + 269, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 181, + 269, + 195 + ], + "score": 1.0, + "content": "1.1 PRELIMINARIES AND NOTATION", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 202, + 505, + 242 + ], + "lines": [ + { + "bbox": [ + 105, + 201, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 201, + 171, + 216 + ], + "score": 1.0, + "content": "Given a dataset", + "type": "text" + }, + { + "bbox": [ + 172, + 203, + 285, + 215 + ], + "score": 0.92, + "content": "\\mathcal { X } = \\{ x _ { i } : i = 1 , \\ldots , | \\mathcal { X } | \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 201, + 430, + 216 + ], + "score": 1.0, + "content": ", our goal is to learn the parameters", + "type": "text" + }, + { + "bbox": [ + 430, + 203, + 437, + 213 + ], + "score": 0.82, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 201, + 505, + 216 + ], + "score": 1.0, + "content": "of a model with", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 101, + 210, + 509, + 237 + ], + "spans": [ + { + "bbox": [ + 101, + 210, + 253, + 237 + ], + "score": 1.0, + "content": "respect to an empirical loss function", + "type": "text" + }, + { + "bbox": [ + 253, + 218, + 260, + 230 + ], + "score": 0.82, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 261, + 210, + 306, + 237 + ], + "score": 1.0, + "content": ", defined as", + "type": "text" + }, + { + "bbox": [ + 307, + 214, + 415, + 232 + ], + "score": 0.94, + "content": "\\begin{array} { r } { f ( \\theta ) \\stackrel { \\Delta } { = } \\frac { 1 } { | \\mathcal { X } | } \\sum _ { i = 1 } ^ { | \\mathcal { X } | } F ( x _ { i } ; \\theta ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 210, + 445, + 237 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 445, + 217, + 480, + 230 + ], + "score": 0.93, + "content": "F ( x _ { i } ; \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 480, + 210, + 509, + 237 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 230, + 313, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 230, + 232, + 244 + ], + "score": 1.0, + "content": "loss with respect to a datapoint", + "type": "text" + }, + { + "bbox": [ + 232, + 232, + 243, + 242 + ], + "score": 0.85, + "content": "x _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 230, + 302, + 244 + ], + "score": 1.0, + "content": "and the model", + "type": "text" + }, + { + "bbox": [ + 303, + 231, + 309, + 241 + ], + "score": 0.78, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 230, + 313, + 244 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9, + "bbox_fs": [ + 101, + 201, + 509, + 244 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 247, + 505, + 349 + ], + "lines": [ + { + "bbox": [ + 105, + 246, + 506, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 462, + 261 + ], + "score": 1.0, + "content": "A first-order stochastic optimization algorithm achieves this by iteratively updating", + "type": "text" + }, + { + "bbox": [ + 462, + 248, + 469, + 258 + ], + "score": 0.76, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 469, + 246, + 506, + 261 + ], + "score": 1.0, + "content": "using a", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 104, + 259, + 506, + 277 + ], + "spans": [ + { + "bbox": [ + 104, + 259, + 186, + 277 + ], + "score": 1.0, + "content": "stochastic gradient", + "type": "text" + }, + { + "bbox": [ + 186, + 259, + 255, + 275 + ], + "score": 0.93, + "content": "G \\overset { \\Delta } { = } \\nabla F ( x _ { i } ; \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 259, + 398, + 277 + ], + "score": 1.0, + "content": "computed at a randomly sampled", + "type": "text" + }, + { + "bbox": [ + 398, + 264, + 408, + 273 + ], + "score": 0.82, + "content": "x _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 259, + 506, + 277 + ], + "score": 1.0, + "content": ", producing a sequence", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 104, + 272, + 506, + 288 + ], + "spans": [ + { + "bbox": [ + 104, + 272, + 150, + 288 + ], + "score": 1.0, + "content": "of models", + "type": "text" + }, + { + "bbox": [ + 150, + 273, + 205, + 286 + ], + "score": 0.9, + "content": "\\theta ^ { ( 0 ) } , \\theta ^ { ( 1 ) } , \\ldots", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 272, + 506, + 288 + ], + "score": 1.0, + "content": ". Stochastic optimization algorithms differ in their update equations. For", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 284, + 507, + 300 + ], + "spans": [ + { + "bbox": [ + 104, + 284, + 235, + 300 + ], + "score": 1.0, + "content": "example, the update of SGD is", + "type": "text" + }, + { + "bbox": [ + 235, + 285, + 436, + 298 + ], + "score": 0.89, + "content": "\\bar { \\theta ^ { ( t + 1 ) } } \\bar { \\bf \\Phi } = \\theta ^ { ( t ) } - \\gamma _ { t } \\bar { G } ^ { ( t ) } = \\theta ^ { ( t ) } - \\gamma _ { t } \\nabla F ( x _ { i } ; \\bar { \\theta } ^ { ( t ) } )", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 284, + 468, + 300 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 468, + 288, + 479, + 298 + ], + "score": 0.84, + "content": "\\gamma _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 284, + 507, + 300 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 297, + 504, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 258, + 310 + ], + "score": 1.0, + "content": "learning rate or step size at iteration", + "type": "text" + }, + { + "bbox": [ + 258, + 299, + 263, + 308 + ], + "score": 0.68, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 297, + 504, + 310 + ], + "score": 1.0, + "content": ". A mini-batch version of the stochastic optimization algo-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 104, + 308, + 506, + 322 + ], + "spans": [ + { + "bbox": [ + 104, + 308, + 359, + 322 + ], + "score": 1.0, + "content": "rithm computes the stochastic gradient over mini-batch of size", + "type": "text" + }, + { + "bbox": [ + 359, + 309, + 369, + 318 + ], + "score": 0.82, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 308, + 506, + 322 + ], + "score": 1.0, + "content": "instead of a single datapoint, i.e.,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 320, + 507, + 337 + ], + "spans": [ + { + "bbox": [ + 106, + 320, + 221, + 336 + ], + "score": 0.92, + "content": "\\begin{array} { r } { G \\stackrel { \\Delta } { = } \\frac { 1 } { B } \\sum _ { i = 1 } ^ { B } \\nabla F ( \\widetilde { x } _ { i } ; \\theta ^ { ( t ) } ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 221, + 320, + 254, + 337 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 254, + 323, + 265, + 334 + ], + "score": 0.86, + "content": "\\widetilde { x } _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 320, + 392, + 337 + ], + "score": 1.0, + "content": "’s are randomly sampled from", + "type": "text" + }, + { + "bbox": [ + 392, + 324, + 402, + 333 + ], + "score": 0.78, + "content": "\\mathcal { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 320, + 507, + 337 + ], + "score": 1.0, + "content": ". We will often evaluate", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 334, + 495, + 351 + ], + "spans": [ + { + "bbox": [ + 104, + 334, + 299, + 351 + ], + "score": 1.0, + "content": "performance on an exponential moving average", + "type": "text" + }, + { + "bbox": [ + 299, + 335, + 417, + 349 + ], + "score": 0.92, + "content": "\\bar { \\theta } ^ { ( t ) } = \\alpha \\bar { \\theta } ^ { ( t - 1 ) } + ( 1 - \\alpha ) \\theta ^ { ( t ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 334, + 482, + 351 + ], + "score": 1.0, + "content": "with decay rate", + "type": "text" + }, + { + "bbox": [ + 482, + 339, + 489, + 347 + ], + "score": 0.75, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 490, + 334, + 495, + 351 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14.5, + "bbox_fs": [ + 104, + 246, + 507, + 351 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 353, + 505, + 398 + ], + "lines": [ + { + "bbox": [ + 105, + 353, + 505, + 366 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 338, + 366 + ], + "score": 1.0, + "content": "Our interest is in distributed stochastic optimization using", + "type": "text" + }, + { + "bbox": [ + 339, + 354, + 349, + 363 + ], + "score": 0.81, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 353, + 505, + 366 + ], + "score": 1.0, + "content": "worker machines in charge of comput-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 364, + 505, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 364, + 262, + 377 + ], + "score": 1.0, + "content": "ing stochastic gradients that are sent to", + "type": "text" + }, + { + "bbox": [ + 262, + 365, + 274, + 374 + ], + "score": 0.81, + "content": "M", + "type": "inline_equation" + }, + { + "bbox": [ + 274, + 364, + 441, + 377 + ], + "score": 1.0, + "content": "parameter servers. Each parameter server", + "type": "text" + }, + { + "bbox": [ + 441, + 365, + 447, + 376 + ], + "score": 0.83, + "content": "j", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 364, + 505, + 377 + ], + "score": 1.0, + "content": "is responsible", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 374, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 186, + 389 + ], + "score": 1.0, + "content": "for storing a subset", + "type": "text" + }, + { + "bbox": [ + 187, + 375, + 203, + 387 + ], + "score": 0.9, + "content": "\\theta [ j ]", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 374, + 372, + 389 + ], + "score": 1.0, + "content": "of the model, and performing updates on", + "type": "text" + }, + { + "bbox": [ + 372, + 375, + 388, + 387 + ], + "score": 0.91, + "content": "\\theta [ j ]", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 374, + 505, + 389 + ], + "score": 1.0, + "content": ". In the synchronous setting,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 386, + 409, + 399 + ], + "spans": [ + { + "bbox": [ + 106, + 386, + 240, + 399 + ], + "score": 1.0, + "content": "we will also introduce additional", + "type": "text" + }, + { + "bbox": [ + 240, + 387, + 245, + 396 + ], + "score": 0.53, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 386, + 409, + 399 + ], + "score": 1.0, + "content": "backup workers for straggler mitigation.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5, + "bbox_fs": [ + 105, + 353, + 505, + 399 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 413, + 362, + 426 + ], + "lines": [ + { + "bbox": [ + 104, + 412, + 363, + 428 + ], + "spans": [ + { + "bbox": [ + 104, + 412, + 363, + 428 + ], + "score": 1.0, + "content": "2 ASYNCHRONOUS STOCHASTIC OPTIMIZATION", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 108, + 438, + 505, + 493 + ], + "lines": [ + { + "bbox": [ + 106, + 438, + 504, + 450 + ], + "spans": [ + { + "bbox": [ + 106, + 438, + 504, + 450 + ], + "score": 1.0, + "content": "An approach for a distributed stochastic gradient descent algorithm was presented in Dean et al.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 449, + 505, + 462 + ], + "spans": [ + { + "bbox": [ + 106, + 449, + 505, + 462 + ], + "score": 1.0, + "content": "(2012), consisting of two main ingredients. First, the parameters of the model are distributed on", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 459, + 506, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 506, + 474 + ], + "score": 1.0, + "content": "multiple servers, depending on the architecture. This set of servers are called the parameter servers.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 469, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 505, + 486 + ], + "score": 1.0, + "content": "Second, there can be multiple workers processing data in parallel and communicating with the pa-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 482, + 505, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 505, + 494 + ], + "score": 1.0, + "content": "rameter servers. Each worker processes a mini-batch of data independently of the others, as follows:", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26, + "bbox_fs": [ + 105, + 438, + 506, + 494 + ] + }, + { + "type": "list", + "bbox": [ + 132, + 502, + 504, + 566 + ], + "lines": [ + { + "bbox": [ + 132, + 502, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 132, + 502, + 505, + 515 + ], + "score": 1.0, + "content": "• The worker fetches from the parameter servers the most up-to-date parameters of the model", + "type": "text" + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 513, + 309, + 525 + ], + "spans": [ + { + "bbox": [ + 141, + 513, + 309, + 525 + ], + "score": 1.0, + "content": "needed to process the current mini-batch;", + "type": "text" + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 132, + 527, + 427, + 541 + ], + "spans": [ + { + "bbox": [ + 132, + 527, + 427, + 541 + ], + "score": 1.0, + "content": "• It then computes gradients of the loss with respect to these parameters;", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 131, + 541, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 131, + 541, + 505, + 555 + ], + "score": 1.0, + "content": "• Finally, these gradients are sent back to the parameter servers, which then updates the", + "type": "text" + } + ], + "index": 32, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 553, + 221, + 567 + ], + "spans": [ + { + "bbox": [ + 141, + 553, + 221, + 567 + ], + "score": 1.0, + "content": "model accordingly.", + "type": "text" + } + ], + "index": 33, + "is_list_end_line": true + } + ], + "index": 31, + "bbox_fs": [ + 131, + 502, + 505, + 567 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 574, + 505, + 619 + ], + "lines": [ + { + "bbox": [ + 105, + 573, + 506, + 587 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 506, + 587 + ], + "score": 1.0, + "content": "Since each worker communicates with the parameter servers independently of the others, this is", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 584, + 505, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 505, + 598 + ], + "score": 1.0, + "content": "called Asynchronous Stochastic Gradient Descent (Async-SGD), or more generally, Asynchronous", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 596, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 505, + 609 + ], + "score": 1.0, + "content": "Stochastic Optimization (Async-Opt). A similar approach was later proposed by Chilimbi et al.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 607, + 327, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 327, + 620 + ], + "score": 1.0, + "content": "(2014). Async-Opt is presented in Algorithms 1 and 2.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 573, + 506, + 620 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 623, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 624, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 505, + 636 + ], + "score": 1.0, + "content": "In practice, the updates of Async-Opt are different than those of serially running the stochastic", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 634, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 634, + 505, + 649 + ], + "score": 1.0, + "content": "optimization algorithm for two reasons. Firstly, the read operation (Algo 1 Line 2) on a worker may", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 104, + 646, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 104, + 646, + 473, + 661 + ], + "score": 1.0, + "content": "be interleaved with updates by other workers to different parameter servers, so the resultant", + "type": "text" + }, + { + "bbox": [ + 473, + 646, + 484, + 659 + ], + "score": 0.9, + "content": "\\widehat { \\theta } _ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 646, + 505, + 661 + ], + "score": 1.0, + "content": "may", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 659, + 506, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 303, + 673 + ], + "score": 1.0, + "content": "not be consistent with any parameter incarnation", + "type": "text" + }, + { + "bbox": [ + 304, + 659, + 319, + 670 + ], + "score": 0.89, + "content": "\\boldsymbol { \\theta } ^ { ( t ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 659, + 506, + 673 + ], + "score": 1.0, + "content": ". Secondly, model updates may have occurred", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "score": 1.0, + "content": "while a worker is computing its stochastic gradient; hence, the resultant gradients are typically", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 682, + 505, + 695 + ], + "spans": [ + { + "bbox": [ + 106, + 682, + 505, + 695 + ], + "score": 1.0, + "content": "computed with respect to outdated parameters. We refer to these as stale gradients, and its staleness", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 693, + 504, + 705 + ], + "spans": [ + { + "bbox": [ + 106, + 693, + 504, + 705 + ], + "score": 1.0, + "content": "as the number of updates that have occurred between its corresponding read and update operations.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 41, + "bbox_fs": [ + 104, + 624, + 506, + 705 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "Understanding the theoretical impact of staleness is difficult work and the topic of many recent", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "papers, e.g. Recht et al. (2011); Duchi et al. (2013); Leblond et al. (2016); Reddi et al. (2015);", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45.5, + "bbox_fs": [ + 105, + 709, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 86, + 253, + 97 + ], + "lines": [ + { + "bbox": [ + 106, + 84, + 253, + 99 + ], + "spans": [ + { + "bbox": [ + 106, + 84, + 245, + 99 + ], + "score": 1.0, + "content": "Algorithm 1: Async-SGD worker", + "type": "text" + }, + { + "bbox": [ + 246, + 86, + 253, + 96 + ], + "score": 0.26, + "content": "k", + "type": "inline_equation" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 98, + 100, + 264, + 219 + ], + "lines": [ + { + "bbox": [ + 105, + 99, + 171, + 109 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 162, + 109 + ], + "score": 1.0, + "content": "Input: Dataset", + "type": "text" + }, + { + "bbox": [ + 162, + 100, + 171, + 108 + ], + "score": 0.54, + "content": "\\mathcal { X }", + "type": "inline_equation" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 108, + 200, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 108, + 132, + 119 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 133, + 110, + 141, + 118 + ], + "score": 0.68, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 108, + 200, + 119 + ], + "score": 1.0, + "content": "mini-batch size", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 98, + 118, + 160, + 129 + ], + "spans": [ + { + "bbox": [ + 98, + 118, + 160, + 129 + ], + "score": 1.0, + "content": "1 while True do", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 99, + 128, + 265, + 143 + ], + "spans": [ + { + "bbox": [ + 99, + 133, + 104, + 140 + ], + "score": 1.0, + "content": "2", + "type": "text" + }, + { + "bbox": [ + 119, + 128, + 142, + 143 + ], + "score": 1.0, + "content": "Read", + "type": "text" + }, + { + "bbox": [ + 142, + 129, + 226, + 142 + ], + "score": 0.88, + "content": "\\widehat { \\theta } _ { k } = ( \\theta [ 0 ] , \\ldots , \\theta [ M ] )", + "type": "inline_equation" + }, + { + "bbox": [ + 226, + 128, + 265, + 143 + ], + "score": 1.0, + "content": "from PSs.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 98, + 137, + 167, + 162 + ], + "spans": [ + { + "bbox": [ + 98, + 145, + 104, + 154 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 122, + 141, + 159, + 155 + ], + "score": 0.86, + "content": "G _ { k } ^ { ( t ) } : = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 137, + 167, + 162 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 98, + 154, + 199, + 164 + ], + "spans": [ + { + "bbox": [ + 98, + 156, + 104, + 164 + ], + "score": 1.0, + "content": "4", + "type": "text" + }, + { + "bbox": [ + 120, + 154, + 135, + 164 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 136, + 154, + 185, + 164 + ], + "score": 0.74, + "content": "i = 1 , \\ldots , B", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 154, + 199, + 164 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 98, + 163, + 244, + 174 + ], + "spans": [ + { + "bbox": [ + 98, + 166, + 104, + 174 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 136, + 163, + 201, + 174 + ], + "score": 1.0, + "content": "Sample datapoint", + "type": "text" + }, + { + "bbox": [ + 202, + 164, + 212, + 173 + ], + "score": 0.79, + "content": "\\widetilde { x } _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 163, + 232, + 174 + ], + "score": 1.0, + "content": "from", + "type": "text" + }, + { + "bbox": [ + 232, + 164, + 241, + 173 + ], + "score": 0.75, + "content": "\\mathcal { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 163, + 244, + 174 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 98, + 174, + 249, + 189 + ], + "spans": [ + { + "bbox": [ + 98, + 179, + 104, + 187 + ], + "score": 1.0, + "content": "6", + "type": "text" + }, + { + "bbox": [ + 137, + 174, + 249, + 189 + ], + "score": 0.5, + "content": "\\begin{array} { r } { G _ { k } ^ { ( t ) } G _ { k } ^ { ( t ) } + \\frac { 1 } { B } \\nabla F ( \\widetilde { x } _ { i } ; \\widehat { \\theta } _ { k } ) . } \\end{array}", + "type": "inline_equation" + } + ], + "index": 8 + }, + { + "bbox": [ + 98, + 187, + 139, + 198 + ], + "spans": [ + { + "bbox": [ + 98, + 190, + 104, + 198 + ], + "score": 1.0, + "content": "7", + "type": "text" + }, + { + "bbox": [ + 120, + 187, + 139, + 198 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 97, + 194, + 238, + 218 + ], + "spans": [ + { + "bbox": [ + 97, + 202, + 105, + 212 + ], + "score": 1.0, + "content": "8", + "type": "text" + }, + { + "bbox": [ + 117, + 194, + 142, + 218 + ], + "score": 1.0, + "content": "Send", + "type": "text" + }, + { + "bbox": [ + 142, + 199, + 159, + 212 + ], + "score": 0.9, + "content": "G _ { k } ^ { ( t ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 194, + 238, + 218 + ], + "score": 1.0, + "content": "to parameter servers.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 95, + 212, + 124, + 222 + ], + "spans": [ + { + "bbox": [ + 95, + 212, + 124, + 222 + ], + "score": 1.0, + "content": "9 end", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 6 + }, + { + "type": "title", + "bbox": [ + 311, + 85, + 495, + 97 + ], + "lines": [ + { + "bbox": [ + 309, + 83, + 497, + 100 + ], + "spans": [ + { + "bbox": [ + 309, + 83, + 497, + 100 + ], + "score": 1.0, + "content": "Algorithm 2: Async-SGD Parameter Server j", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 301, + 100, + 466, + 189 + ], + "lines": [ + { + "bbox": [ + 309, + 99, + 429, + 111 + ], + "spans": [ + { + "bbox": [ + 309, + 99, + 335, + 111 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 335, + 101, + 374, + 110 + ], + "score": 0.67, + "content": "\\gamma _ { 0 } , \\gamma _ { 1 } , \\ldots", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 99, + 429, + 111 + ], + "score": 1.0, + "content": "learning rates.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 309, + 109, + 385, + 119 + ], + "spans": [ + { + "bbox": [ + 309, + 109, + 335, + 119 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 336, + 111, + 343, + 118 + ], + "score": 0.54, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 109, + 385, + 119 + ], + "score": 1.0, + "content": "decay rate.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 308, + 118, + 428, + 132 + ], + "spans": [ + { + "bbox": [ + 308, + 118, + 335, + 132 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 336, + 119, + 351, + 129 + ], + "score": 0.79, + "content": "\\theta ^ { ( 0 ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 118, + 428, + 132 + ], + "score": 1.0, + "content": "model initialization.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 303, + 129, + 383, + 141 + ], + "spans": [ + { + "bbox": [ + 303, + 129, + 322, + 141 + ], + "score": 1.0, + "content": "1 for", + "type": "text" + }, + { + "bbox": [ + 323, + 131, + 367, + 140 + ], + "score": 0.83, + "content": "t = 0 , 1 , \\ldots", + "type": "inline_equation" + }, + { + "bbox": [ + 368, + 129, + 383, + 141 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 300, + 139, + 461, + 151 + ], + "spans": [ + { + "bbox": [ + 300, + 142, + 308, + 150 + ], + "score": 1.0, + "content": "2", + "type": "text" + }, + { + "bbox": [ + 324, + 139, + 388, + 151 + ], + "score": 1.0, + "content": "Wait for gradient", + "type": "text" + }, + { + "bbox": [ + 388, + 141, + 397, + 149 + ], + "score": 0.81, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 139, + 461, + 151 + ], + "score": 1.0, + "content": "from any worker.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 300, + 149, + 436, + 165 + ], + "spans": [ + { + "bbox": [ + 300, + 154, + 308, + 163 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 324, + 151, + 432, + 163 + ], + "score": 0.8, + "content": "\\theta ^ { ( t + 1 ) } [ j ] \\theta ^ { ( t ) } [ j ] - \\gamma _ { t } G [ j ]", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 149, + 436, + 165 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 300, + 162, + 467, + 177 + ], + "spans": [ + { + "bbox": [ + 300, + 166, + 308, + 175 + ], + "score": 1.0, + "content": "4", + "type": "text" + }, + { + "bbox": [ + 325, + 164, + 464, + 176 + ], + "score": 0.78, + "content": "\\bar { \\theta } ^ { ( t ) } [ j ] = \\alpha \\bar { \\theta } ^ { ( t - 1 ) } [ j ] + ( 1 - \\alpha ) \\theta ^ { ( t ) } [ j ] ,", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 162, + 467, + 177 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 300, + 175, + 327, + 186 + ], + "spans": [ + { + "bbox": [ + 300, + 177, + 311, + 186 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 306, + 175, + 327, + 186 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14.5 + }, + { + "type": "text", + "bbox": [ + 99, + 213, + 122, + 221 + ], + "lines": [ + { + "bbox": [ + 99, + 213, + 122, + 221 + ], + "spans": [], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "image", + "bbox": [ + 112, + 259, + 356, + 341 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 112, + 259, + 356, + 341 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 112, + 259, + 356, + 341 + ], + "spans": [ + { + "bbox": [ + 112, + 259, + 356, + 341 + ], + "score": 0.961, + "type": "image", + "image_path": "869a74e931a0a7ff1e7216146dd0c69e43230ff7820846197c9038f2307065dd.jpg" + } + ] + } + ], + "index": 25.0, + "virtual_lines": [ + { + "bbox": [ + 112, + 259, + 356, + 272.6666666666667 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 112, + 272.6666666666667, + 356, + 286.33333333333337 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 112, + 286.33333333333337, + 356, + 300.00000000000006 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 112, + 300.00000000000006, + 356, + 313.66666666666674 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 112, + 313.66666666666674, + 356, + 327.3333333333334 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 112, + 327.3333333333334, + 356, + 341.0000000000001 + ], + "spans": [], + "index": 28 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 356, + 362, + 406 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 356, + 362, + 367 + ], + "spans": [ + { + "bbox": [ + 106, + 356, + 362, + 367 + ], + "score": 1.0, + "content": "Figure 1: Gradient staleness dependence on model layer. Gradients", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 366, + 363, + 378 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 363, + 378 + ], + "score": 1.0, + "content": "are computed in a bottom-up forward propagation step followed by a", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 377, + 362, + 387 + ], + "spans": [ + { + "bbox": [ + 106, + 377, + 362, + 387 + ], + "score": 1.0, + "content": "top-down back propagation step. Parameters are read from servers in", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 384, + 363, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 363, + 399 + ], + "score": 1.0, + "content": "the forward prop, but gradients are sent to servers during the back prop.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 396, + 330, + 408 + ], + "spans": [ + { + "bbox": [ + 106, + 396, + 330, + 408 + ], + "score": 1.0, + "content": "Thus, gradients of lower layers are more stale than top layers.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 33 + } + ], + "index": 29.0 + }, + { + "type": "image", + "bbox": [ + 369, + 255, + 502, + 354 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 369, + 255, + 502, + 354 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 369, + 255, + 502, + 354 + ], + "spans": [ + { + "bbox": [ + 369, + 255, + 502, + 354 + ], + "score": 0.959, + "type": "image", + "image_path": "067a6882cd5a5473a6949076399e8dc649d5d54797b44d7ec5ef733add6828af.jpg" + } + ] + } + ], + "index": 27.0, + "virtual_lines": [ + { + "bbox": [ + 369, + 255, + 502, + 304.5 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 369, + 304.5, + 502, + 354.0 + ], + "spans": [], + "index": 29 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 367, + 365, + 504, + 406 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 367, + 365, + 505, + 377 + ], + "spans": [ + { + "bbox": [ + 367, + 365, + 505, + 377 + ], + "score": 1.0, + "content": "Figure 2: Degradation of test classi-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 367, + 374, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 367, + 374, + 505, + 387 + ], + "score": 1.0, + "content": "fication error with increasing average", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 366, + 385, + 506, + 396 + ], + "spans": [ + { + "bbox": [ + 366, + 385, + 506, + 396 + ], + "score": 1.0, + "content": "gradient staleness in MNIST CNN", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 367, + 395, + 395, + 405 + ], + "spans": [ + { + "bbox": [ + 367, + 395, + 395, + 405 + ], + "score": 1.0, + "content": "model.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 35.0 + } + ], + "index": 31.0 + }, + { + "type": "text", + "bbox": [ + 106, + 433, + 505, + 511 + ], + "lines": [ + { + "bbox": [ + 105, + 432, + 506, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 432, + 506, + 448 + ], + "score": 1.0, + "content": "De Sa et al. (2015); Mania et al. (2015), most of which focus on individual algorithms, under strong", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 446, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 505, + 457 + ], + "score": 1.0, + "content": "assumptions that may not hold up in practice. This is further complicated by deep models with mul-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 457, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 505, + 468 + ], + "score": 1.0, + "content": "tiple layers, since the times at which model parameters are read and which gradients are computed", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 468, + 505, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 468, + 505, + 479 + ], + "score": 1.0, + "content": "and sent are dependent on the depth of the layers (Figure 1). To better understand this dependence", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 478, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 505, + 491 + ], + "score": 1.0, + "content": "in real models, we collected staleness statistics on a Async-Opt run with 40 workers on a 18-layer", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 489, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 505, + 501 + ], + "score": 1.0, + "content": "Inception model (Szegedy et al., 2016) trained on the ImageNet Challenge dataset (Russakovsky", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 501, + 243, + 512 + ], + "spans": [ + { + "bbox": [ + 106, + 501, + 243, + 512 + ], + "score": 1.0, + "content": "et al., 2015), as shown in Table 1.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 106, + 517, + 254, + 605 + ], + "lines": [ + { + "bbox": [ + 106, + 517, + 253, + 528 + ], + "spans": [ + { + "bbox": [ + 106, + 517, + 253, + 528 + ], + "score": 1.0, + "content": "Despite the abovementioned prob-", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 528, + 254, + 539 + ], + "spans": [ + { + "bbox": [ + 106, + 528, + 254, + 539 + ], + "score": 1.0, + "content": "lems, Async-Opt has been shown to", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 539, + 255, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 539, + 255, + 550 + ], + "score": 1.0, + "content": "be scale well up to a few dozens of", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 550, + 254, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 254, + 561 + ], + "score": 1.0, + "content": "workers for some models. However,", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 561, + 254, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 254, + 572 + ], + "score": 1.0, + "content": "at larger scales, increasing the num-", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 571, + 254, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 571, + 254, + 583 + ], + "score": 1.0, + "content": "ber of machines (and thus staleness", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 582, + 254, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 254, + 595 + ], + "score": 1.0, + "content": "of gradients) can result in poorer", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 106, + 594, + 171, + 605 + ], + "spans": [ + { + "bbox": [ + 106, + 594, + 171, + 605 + ], + "score": 1.0, + "content": "trained models.", + "type": "text" + } + ], + "index": 53 + } + ], + "index": 49.5 + }, + { + "type": "table", + "bbox": [ + 261, + 509, + 506, + 561 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 261, + 509, + 506, + 561 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 261, + 509, + 506, + 561 + ], + "spans": [ + { + "bbox": [ + 261, + 509, + 506, + 561 + ], + "score": 0.975, + "html": "
LayerMinMeanMedianMaxStd DevCount
18414.5413.94293.8310908
12511.3511.3233.0944478
11819.819.59343.65187
02438.9738.43615.43178
", + "type": "table", + "image_path": "02bec36451fb35c343bccde0a8bb365f5fa1c3f48434be8a9f82c3f421e4e645.jpg" + } + ] + } + ], + "index": 55, + "virtual_lines": [ + { + "bbox": [ + 261, + 509, + 506, + 526.3333333333334 + ], + "spans": [], + "index": 54 + }, + { + "bbox": [ + 261, + 526.3333333333334, + 506, + 543.6666666666667 + ], + "spans": [], + "index": 55 + }, + { + "bbox": [ + 261, + 543.6666666666667, + 506, + 561.0000000000001 + ], + "spans": [], + "index": 56 + } + ] + } + ], + "index": 55 + }, + { + "type": "text", + "bbox": [ + 261, + 570, + 505, + 641 + ], + "lines": [ + { + "bbox": [ + 261, + 569, + 505, + 582 + ], + "spans": [ + { + "bbox": [ + 261, + 569, + 505, + 582 + ], + "score": 1.0, + "content": "Table 1: Staleness of gradients in a 18-layer Inception model. Gra-", + "type": "text" + } + ], + "index": 57 + }, + { + "bbox": [ + 261, + 581, + 505, + 592 + ], + "spans": [ + { + "bbox": [ + 261, + 581, + 505, + 592 + ], + "score": 1.0, + "content": "dients were collected in a run of asynchronous training using 40", + "type": "text" + } + ], + "index": 58 + }, + { + "bbox": [ + 261, + 591, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 261, + 591, + 506, + 601 + ], + "score": 1.0, + "content": "machines. Staleness of a gradient is measured as the number of", + "type": "text" + } + ], + "index": 59 + }, + { + "bbox": [ + 261, + 600, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 261, + 600, + 505, + 612 + ], + "score": 1.0, + "content": "updates that have occurred between its corresponding read and up-", + "type": "text" + } + ], + "index": 60 + }, + { + "bbox": [ + 262, + 611, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 262, + 611, + 505, + 622 + ], + "score": 1.0, + "content": "date operations. The staleness of gradients increases from a mean", + "type": "text" + } + ], + "index": 61 + }, + { + "bbox": [ + 261, + 620, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 261, + 620, + 271, + 632 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 272, + 621, + 296, + 630 + ], + "score": 0.87, + "content": "{ \\sim } 1 4 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 620, + 407, + 632 + ], + "score": 1.0, + "content": "in the top layer (Layer 18) to", + "type": "text" + }, + { + "bbox": [ + 407, + 621, + 432, + 631 + ], + "score": 0.86, + "content": "{ \\sim } 3 9 . 0 ", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 620, + 505, + 632 + ], + "score": 1.0, + "content": "in the bottom layer", + "type": "text" + } + ], + "index": 64 + }, + { + "bbox": [ + 261, + 630, + 300, + 643 + ], + "spans": [ + { + "bbox": [ + 261, + 630, + 300, + 643 + ], + "score": 1.0, + "content": "(Layer 0).", + "type": "text" + } + ], + "index": 65 + } + ], + "index": 60 + }, + { + "type": "title", + "bbox": [ + 107, + 626, + 243, + 648 + ], + "lines": [ + { + "bbox": [ + 105, + 624, + 245, + 638 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 245, + 638 + ], + "score": 1.0, + "content": "2.1 IMPACT OF STALENESS ON", + "type": "text" + } + ], + "index": 63 + }, + { + "bbox": [ + 106, + 637, + 180, + 648 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 180, + 648 + ], + "score": 1.0, + "content": "TEST ACCURACY", + "type": "text" + } + ], + "index": 62 + } + ], + "index": 62.5 + }, + { + "type": "text", + "bbox": [ + 107, + 659, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "We explore how increased staleness contributes to training of poorer models. In order to mimic the", + "type": "text" + } + ], + "index": 66 + }, + { + "bbox": [ + 105, + 671, + 505, + 682 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 505, + 682 + ], + "score": 1.0, + "content": "setting on a smaller scale, we trained a state-of-the-art MNIST CNN model but simulated staleness", + "type": "text" + } + ], + "index": 67 + }, + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "score": 1.0, + "content": "by using old gradients for the parameter updates. Details of the model and training are provided in", + "type": "text" + } + ], + "index": 68 + }, + { + "bbox": [ + 105, + 693, + 168, + 705 + ], + "spans": [ + { + "bbox": [ + 105, + 693, + 168, + 705 + ], + "score": 1.0, + "content": "Appendix A.1.", + "type": "text" + } + ], + "index": 69 + } + ], + "index": 67.5 + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 707, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 707, + 312, + 723 + ], + "score": 1.0, + "content": "The best final classification error on a test set was", + "type": "text" + }, + { + "bbox": [ + 313, + 710, + 339, + 720 + ], + "score": 0.87, + "content": "0 . 3 6 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 707, + 422, + 723 + ], + "score": 1.0, + "content": ", which increases to", + "type": "text" + }, + { + "bbox": [ + 422, + 710, + 449, + 720 + ], + "score": 0.85, + "content": "0 . 4 7 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 707, + 505, + 723 + ], + "score": 1.0, + "content": "with average", + "type": "text" + } + ], + "index": 70 + }, + { + "bbox": [ + 105, + 720, + 411, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 267, + 733 + ], + "score": 1.0, + "content": "gradient staleness of 20 steps, and up to", + "type": "text" + }, + { + "bbox": [ + 267, + 721, + 294, + 731 + ], + "score": 0.88, + "content": "0 . 7 9 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 720, + 411, + 733 + ], + "score": 1.0, + "content": "with 50 steps (see Figure 2).", + "type": "text" + } + ], + "index": 71 + } + ], + "index": 70.5 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 25, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 25, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2017", + "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": "title", + "bbox": [ + 107, + 86, + 253, + 97 + ], + "lines": [ + { + "bbox": [ + 106, + 84, + 253, + 99 + ], + "spans": [ + { + "bbox": [ + 106, + 84, + 245, + 99 + ], + "score": 1.0, + "content": "Algorithm 1: Async-SGD worker", + "type": "text" + }, + { + "bbox": [ + 246, + 86, + 253, + 96 + ], + "score": 0.26, + "content": "k", + "type": "inline_equation" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "index", + "bbox": [ + 98, + 100, + 264, + 219 + ], + "lines": [ + { + "bbox": [ + 105, + 99, + 171, + 109 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 162, + 109 + ], + "score": 1.0, + "content": "Input: Dataset", + "type": "text" + }, + { + "bbox": [ + 162, + 100, + 171, + 108 + ], + "score": 0.54, + "content": "\\mathcal { X }", + "type": "inline_equation" + } + ], + "index": 1, + "is_list_start_line": true + }, + { + "bbox": [ + 105, + 108, + 200, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 108, + 132, + 119 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 133, + 110, + 141, + 118 + ], + "score": 0.68, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 108, + 200, + 119 + ], + "score": 1.0, + "content": "mini-batch size", + "type": "text" + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 98, + 118, + 160, + 129 + ], + "spans": [ + { + "bbox": [ + 98, + 118, + 160, + 129 + ], + "score": 1.0, + "content": "1 while True do", + "type": "text" + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 99, + 128, + 265, + 143 + ], + "spans": [ + { + "bbox": [ + 99, + 133, + 104, + 140 + ], + "score": 1.0, + "content": "2", + "type": "text" + }, + { + "bbox": [ + 119, + 128, + 142, + 143 + ], + "score": 1.0, + "content": "Read", + "type": "text" + }, + { + "bbox": [ + 142, + 129, + 226, + 142 + ], + "score": 0.88, + "content": "\\widehat { \\theta } _ { k } = ( \\theta [ 0 ] , \\ldots , \\theta [ M ] )", + "type": "inline_equation" + }, + { + "bbox": [ + 226, + 128, + 265, + 143 + ], + "score": 1.0, + "content": "from PSs.", + "type": "text" + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 98, + 137, + 167, + 162 + ], + "spans": [ + { + "bbox": [ + 98, + 145, + 104, + 154 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 122, + 141, + 159, + 155 + ], + "score": 0.86, + "content": "G _ { k } ^ { ( t ) } : = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 137, + 167, + 162 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 98, + 154, + 199, + 164 + ], + "spans": [ + { + "bbox": [ + 98, + 156, + 104, + 164 + ], + "score": 1.0, + "content": "4", + "type": "text" + }, + { + "bbox": [ + 120, + 154, + 135, + 164 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 136, + 154, + 185, + 164 + ], + "score": 0.74, + "content": "i = 1 , \\ldots , B", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 154, + 199, + 164 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 98, + 163, + 244, + 174 + ], + "spans": [ + { + "bbox": [ + 98, + 166, + 104, + 174 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 136, + 163, + 201, + 174 + ], + "score": 1.0, + "content": "Sample datapoint", + "type": "text" + }, + { + "bbox": [ + 202, + 164, + 212, + 173 + ], + "score": 0.79, + "content": "\\widetilde { x } _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 163, + 232, + 174 + ], + "score": 1.0, + "content": "from", + "type": "text" + }, + { + "bbox": [ + 232, + 164, + 241, + 173 + ], + "score": 0.75, + "content": "\\mathcal { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 163, + 244, + 174 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 98, + 174, + 249, + 189 + ], + "spans": [ + { + "bbox": [ + 98, + 179, + 104, + 187 + ], + "score": 1.0, + "content": "6", + "type": "text" + }, + { + "bbox": [ + 137, + 174, + 249, + 189 + ], + "score": 0.5, + "content": "\\begin{array} { r } { G _ { k } ^ { ( t ) } G _ { k } ^ { ( t ) } + \\frac { 1 } { B } \\nabla F ( \\widetilde { x } _ { i } ; \\widehat { \\theta } _ { k } ) . } \\end{array}", + "type": "inline_equation" + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 98, + 187, + 139, + 198 + ], + "spans": [ + { + "bbox": [ + 98, + 190, + 104, + 198 + ], + "score": 1.0, + "content": "7", + "type": "text" + }, + { + "bbox": [ + 120, + 187, + 139, + 198 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 97, + 194, + 238, + 218 + ], + "spans": [ + { + "bbox": [ + 97, + 202, + 105, + 212 + ], + "score": 1.0, + "content": "8", + "type": "text" + }, + { + "bbox": [ + 117, + 194, + 142, + 218 + ], + "score": 1.0, + "content": "Send", + "type": "text" + }, + { + "bbox": [ + 142, + 199, + 159, + 212 + ], + "score": 0.9, + "content": "G _ { k } ^ { ( t ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 194, + 238, + 218 + ], + "score": 1.0, + "content": "to parameter servers.", + "type": "text" + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 95, + 212, + 124, + 222 + ], + "spans": [ + { + "bbox": [ + 95, + 212, + 124, + 222 + ], + "score": 1.0, + "content": "9 end", + "type": "text" + } + ], + "index": 20, + "is_list_start_line": true + } + ], + "index": 6, + "bbox_fs": [ + 95, + 99, + 265, + 222 + ] + }, + { + "type": "title", + "bbox": [ + 311, + 85, + 495, + 97 + ], + "lines": [ + { + "bbox": [ + 309, + 83, + 497, + 100 + ], + "spans": [ + { + "bbox": [ + 309, + 83, + 497, + 100 + ], + "score": 1.0, + "content": "Algorithm 2: Async-SGD Parameter Server j", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 301, + 100, + 466, + 189 + ], + "lines": [ + { + "bbox": [ + 309, + 99, + 429, + 111 + ], + "spans": [ + { + "bbox": [ + 309, + 99, + 335, + 111 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 335, + 101, + 374, + 110 + ], + "score": 0.67, + "content": "\\gamma _ { 0 } , \\gamma _ { 1 } , \\ldots", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 99, + 429, + 111 + ], + "score": 1.0, + "content": "learning rates.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 309, + 109, + 385, + 119 + ], + "spans": [ + { + "bbox": [ + 309, + 109, + 335, + 119 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 336, + 111, + 343, + 118 + ], + "score": 0.54, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 109, + 385, + 119 + ], + "score": 1.0, + "content": "decay rate.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 308, + 118, + 428, + 132 + ], + "spans": [ + { + "bbox": [ + 308, + 118, + 335, + 132 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 336, + 119, + 351, + 129 + ], + "score": 0.79, + "content": "\\theta ^ { ( 0 ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 118, + 428, + 132 + ], + "score": 1.0, + "content": "model initialization.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 303, + 129, + 383, + 141 + ], + "spans": [ + { + "bbox": [ + 303, + 129, + 322, + 141 + ], + "score": 1.0, + "content": "1 for", + "type": "text" + }, + { + "bbox": [ + 323, + 131, + 367, + 140 + ], + "score": 0.83, + "content": "t = 0 , 1 , \\ldots", + "type": "inline_equation" + }, + { + "bbox": [ + 368, + 129, + 383, + 141 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 300, + 139, + 461, + 151 + ], + "spans": [ + { + "bbox": [ + 300, + 142, + 308, + 150 + ], + "score": 1.0, + "content": "2", + "type": "text" + }, + { + "bbox": [ + 324, + 139, + 388, + 151 + ], + "score": 1.0, + "content": "Wait for gradient", + "type": "text" + }, + { + "bbox": [ + 388, + 141, + 397, + 149 + ], + "score": 0.81, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 139, + 461, + 151 + ], + "score": 1.0, + "content": "from any worker.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 300, + 149, + 436, + 165 + ], + "spans": [ + { + "bbox": [ + 300, + 154, + 308, + 163 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 324, + 151, + 432, + 163 + ], + "score": 0.8, + "content": "\\theta ^ { ( t + 1 ) } [ j ] \\theta ^ { ( t ) } [ j ] - \\gamma _ { t } G [ j ]", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 149, + 436, + 165 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 300, + 162, + 467, + 177 + ], + "spans": [ + { + "bbox": [ + 300, + 166, + 308, + 175 + ], + "score": 1.0, + "content": "4", + "type": "text" + }, + { + "bbox": [ + 325, + 164, + 464, + 176 + ], + "score": 0.78, + "content": "\\bar { \\theta } ^ { ( t ) } [ j ] = \\alpha \\bar { \\theta } ^ { ( t - 1 ) } [ j ] + ( 1 - \\alpha ) \\theta ^ { ( t ) } [ j ] ,", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 162, + 467, + 177 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 300, + 175, + 327, + 186 + ], + "spans": [ + { + "bbox": [ + 300, + 177, + 311, + 186 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 306, + 175, + 327, + 186 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14.5, + "bbox_fs": [ + 300, + 99, + 467, + 186 + ] + }, + { + "type": "text", + "bbox": [ + 99, + 213, + 122, + 221 + ], + "lines": [ + { + "bbox": [ + 99, + 213, + 122, + 221 + ], + "spans": [], + "index": 21 + } + ], + "index": 21, + "bbox_fs": [ + 99, + 213, + 122, + 221 + ] + }, + { + "type": "image", + "bbox": [ + 112, + 259, + 356, + 341 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 112, + 259, + 356, + 341 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 112, + 259, + 356, + 341 + ], + "spans": [ + { + "bbox": [ + 112, + 259, + 356, + 341 + ], + "score": 0.961, + "type": "image", + "image_path": "869a74e931a0a7ff1e7216146dd0c69e43230ff7820846197c9038f2307065dd.jpg" + } + ] + } + ], + "index": 25.0, + "virtual_lines": [ + { + "bbox": [ + 112, + 259, + 356, + 272.6666666666667 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 112, + 272.6666666666667, + 356, + 286.33333333333337 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 112, + 286.33333333333337, + 356, + 300.00000000000006 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 112, + 300.00000000000006, + 356, + 313.66666666666674 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 112, + 313.66666666666674, + 356, + 327.3333333333334 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 112, + 327.3333333333334, + 356, + 341.0000000000001 + ], + "spans": [], + "index": 28 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 356, + 362, + 406 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 356, + 362, + 367 + ], + "spans": [ + { + "bbox": [ + 106, + 356, + 362, + 367 + ], + "score": 1.0, + "content": "Figure 1: Gradient staleness dependence on model layer. Gradients", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 366, + 363, + 378 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 363, + 378 + ], + "score": 1.0, + "content": "are computed in a bottom-up forward propagation step followed by a", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 377, + 362, + 387 + ], + "spans": [ + { + "bbox": [ + 106, + 377, + 362, + 387 + ], + "score": 1.0, + "content": "top-down back propagation step. Parameters are read from servers in", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 384, + 363, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 363, + 399 + ], + "score": 1.0, + "content": "the forward prop, but gradients are sent to servers during the back prop.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 396, + 330, + 408 + ], + "spans": [ + { + "bbox": [ + 106, + 396, + 330, + 408 + ], + "score": 1.0, + "content": "Thus, gradients of lower layers are more stale than top layers.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 33 + } + ], + "index": 29.0 + }, + { + "type": "image", + "bbox": [ + 369, + 255, + 502, + 354 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 369, + 255, + 502, + 354 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 369, + 255, + 502, + 354 + ], + "spans": [ + { + "bbox": [ + 369, + 255, + 502, + 354 + ], + "score": 0.959, + "type": "image", + "image_path": "067a6882cd5a5473a6949076399e8dc649d5d54797b44d7ec5ef733add6828af.jpg" + } + ] + } + ], + "index": 27.0, + "virtual_lines": [ + { + "bbox": [ + 369, + 255, + 502, + 304.5 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 369, + 304.5, + 502, + 354.0 + ], + "spans": [], + "index": 29 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 367, + 365, + 504, + 406 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 367, + 365, + 505, + 377 + ], + "spans": [ + { + "bbox": [ + 367, + 365, + 505, + 377 + ], + "score": 1.0, + "content": "Figure 2: Degradation of test classi-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 367, + 374, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 367, + 374, + 505, + 387 + ], + "score": 1.0, + "content": "fication error with increasing average", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 366, + 385, + 506, + 396 + ], + "spans": [ + { + "bbox": [ + 366, + 385, + 506, + 396 + ], + "score": 1.0, + "content": "gradient staleness in MNIST CNN", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 367, + 395, + 395, + 405 + ], + "spans": [ + { + "bbox": [ + 367, + 395, + 395, + 405 + ], + "score": 1.0, + "content": "model.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 35.0 + } + ], + "index": 31.0 + }, + { + "type": "text", + "bbox": [ + 106, + 433, + 505, + 511 + ], + "lines": [ + { + "bbox": [ + 105, + 432, + 506, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 432, + 506, + 448 + ], + "score": 1.0, + "content": "De Sa et al. (2015); Mania et al. (2015), most of which focus on individual algorithms, under strong", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 446, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 505, + 457 + ], + "score": 1.0, + "content": "assumptions that may not hold up in practice. This is further complicated by deep models with mul-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 457, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 505, + 468 + ], + "score": 1.0, + "content": "tiple layers, since the times at which model parameters are read and which gradients are computed", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 468, + 505, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 468, + 505, + 479 + ], + "score": 1.0, + "content": "and sent are dependent on the depth of the layers (Figure 1). To better understand this dependence", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 478, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 505, + 491 + ], + "score": 1.0, + "content": "in real models, we collected staleness statistics on a Async-Opt run with 40 workers on a 18-layer", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 489, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 505, + 501 + ], + "score": 1.0, + "content": "Inception model (Szegedy et al., 2016) trained on the ImageNet Challenge dataset (Russakovsky", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 501, + 243, + 512 + ], + "spans": [ + { + "bbox": [ + 106, + 501, + 243, + 512 + ], + "score": 1.0, + "content": "et al., 2015), as shown in Table 1.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 42, + "bbox_fs": [ + 105, + 432, + 506, + 512 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 517, + 254, + 605 + ], + "lines": [ + { + "bbox": [ + 106, + 517, + 253, + 528 + ], + "spans": [ + { + "bbox": [ + 106, + 517, + 253, + 528 + ], + "score": 1.0, + "content": "Despite the abovementioned prob-", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 528, + 254, + 539 + ], + "spans": [ + { + "bbox": [ + 106, + 528, + 254, + 539 + ], + "score": 1.0, + "content": "lems, Async-Opt has been shown to", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 539, + 255, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 539, + 255, + 550 + ], + "score": 1.0, + "content": "be scale well up to a few dozens of", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 550, + 254, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 254, + 561 + ], + "score": 1.0, + "content": "workers for some models. However,", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 561, + 254, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 254, + 572 + ], + "score": 1.0, + "content": "at larger scales, increasing the num-", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 571, + 254, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 571, + 254, + 583 + ], + "score": 1.0, + "content": "ber of machines (and thus staleness", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 582, + 254, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 254, + 595 + ], + "score": 1.0, + "content": "of gradients) can result in poorer", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 106, + 594, + 171, + 605 + ], + "spans": [ + { + "bbox": [ + 106, + 594, + 171, + 605 + ], + "score": 1.0, + "content": "trained models.", + "type": "text" + } + ], + "index": 53 + } + ], + "index": 49.5, + "bbox_fs": [ + 105, + 517, + 255, + 605 + ] + }, + { + "type": "table", + "bbox": [ + 261, + 509, + 506, + 561 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 261, + 509, + 506, + 561 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 261, + 509, + 506, + 561 + ], + "spans": [ + { + "bbox": [ + 261, + 509, + 506, + 561 + ], + "score": 0.975, + "html": "
LayerMinMeanMedianMaxStd DevCount
18414.5413.94293.8310908
12511.3511.3233.0944478
11819.819.59343.65187
02438.9738.43615.43178
", + "type": "table", + "image_path": "02bec36451fb35c343bccde0a8bb365f5fa1c3f48434be8a9f82c3f421e4e645.jpg" + } + ] + } + ], + "index": 55, + "virtual_lines": [ + { + "bbox": [ + 261, + 509, + 506, + 526.3333333333334 + ], + "spans": [], + "index": 54 + }, + { + "bbox": [ + 261, + 526.3333333333334, + 506, + 543.6666666666667 + ], + "spans": [], + "index": 55 + }, + { + "bbox": [ + 261, + 543.6666666666667, + 506, + 561.0000000000001 + ], + "spans": [], + "index": 56 + } + ] + } + ], + "index": 55 + }, + { + "type": "text", + "bbox": [ + 261, + 570, + 505, + 641 + ], + "lines": [ + { + "bbox": [ + 261, + 569, + 505, + 582 + ], + "spans": [ + { + "bbox": [ + 261, + 569, + 505, + 582 + ], + "score": 1.0, + "content": "Table 1: Staleness of gradients in a 18-layer Inception model. Gra-", + "type": "text" + } + ], + "index": 57 + }, + { + "bbox": [ + 261, + 581, + 505, + 592 + ], + "spans": [ + { + "bbox": [ + 261, + 581, + 505, + 592 + ], + "score": 1.0, + "content": "dients were collected in a run of asynchronous training using 40", + "type": "text" + } + ], + "index": 58 + }, + { + "bbox": [ + 261, + 591, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 261, + 591, + 506, + 601 + ], + "score": 1.0, + "content": "machines. Staleness of a gradient is measured as the number of", + "type": "text" + } + ], + "index": 59 + }, + { + "bbox": [ + 261, + 600, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 261, + 600, + 505, + 612 + ], + "score": 1.0, + "content": "updates that have occurred between its corresponding read and up-", + "type": "text" + } + ], + "index": 60 + }, + { + "bbox": [ + 262, + 611, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 262, + 611, + 505, + 622 + ], + "score": 1.0, + "content": "date operations. The staleness of gradients increases from a mean", + "type": "text" + } + ], + "index": 61 + }, + { + "bbox": [ + 261, + 620, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 261, + 620, + 271, + 632 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 272, + 621, + 296, + 630 + ], + "score": 0.87, + "content": "{ \\sim } 1 4 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 620, + 407, + 632 + ], + "score": 1.0, + "content": "in the top layer (Layer 18) to", + "type": "text" + }, + { + "bbox": [ + 407, + 621, + 432, + 631 + ], + "score": 0.86, + "content": "{ \\sim } 3 9 . 0 ", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 620, + 505, + 632 + ], + "score": 1.0, + "content": "in the bottom layer", + "type": "text" + } + ], + "index": 64 + }, + { + "bbox": [ + 261, + 630, + 300, + 643 + ], + "spans": [ + { + "bbox": [ + 261, + 630, + 300, + 643 + ], + "score": 1.0, + "content": "(Layer 0).", + "type": "text" + } + ], + "index": 65 + } + ], + "index": 60, + "bbox_fs": [ + 261, + 569, + 506, + 643 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 626, + 243, + 648 + ], + "lines": [ + { + "bbox": [ + 105, + 624, + 245, + 638 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 245, + 638 + ], + "score": 1.0, + "content": "2.1 IMPACT OF STALENESS ON", + "type": "text" + } + ], + "index": 63 + }, + { + "bbox": [ + 106, + 637, + 180, + 648 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 180, + 648 + ], + "score": 1.0, + "content": "TEST ACCURACY", + "type": "text" + } + ], + "index": 62 + } + ], + "index": 62.5 + }, + { + "type": "text", + "bbox": [ + 107, + 659, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "We explore how increased staleness contributes to training of poorer models. In order to mimic the", + "type": "text" + } + ], + "index": 66 + }, + { + "bbox": [ + 105, + 671, + 505, + 682 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 505, + 682 + ], + "score": 1.0, + "content": "setting on a smaller scale, we trained a state-of-the-art MNIST CNN model but simulated staleness", + "type": "text" + } + ], + "index": 67 + }, + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "score": 1.0, + "content": "by using old gradients for the parameter updates. Details of the model and training are provided in", + "type": "text" + } + ], + "index": 68 + }, + { + "bbox": [ + 105, + 693, + 168, + 705 + ], + "spans": [ + { + "bbox": [ + 105, + 693, + 168, + 705 + ], + "score": 1.0, + "content": "Appendix A.1.", + "type": "text" + } + ], + "index": 69 + } + ], + "index": 67.5, + "bbox_fs": [ + 105, + 660, + 505, + 705 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 707, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 707, + 312, + 723 + ], + "score": 1.0, + "content": "The best final classification error on a test set was", + "type": "text" + }, + { + "bbox": [ + 313, + 710, + 339, + 720 + ], + "score": 0.87, + "content": "0 . 3 6 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 707, + 422, + 723 + ], + "score": 1.0, + "content": ", which increases to", + "type": "text" + }, + { + "bbox": [ + 422, + 710, + 449, + 720 + ], + "score": 0.85, + "content": "0 . 4 7 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 707, + 505, + 723 + ], + "score": 1.0, + "content": "with average", + "type": "text" + } + ], + "index": 70 + }, + { + "bbox": [ + 105, + 720, + 411, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 267, + 733 + ], + "score": 1.0, + "content": "gradient staleness of 20 steps, and up to", + "type": "text" + }, + { + "bbox": [ + 267, + 721, + 294, + 731 + ], + "score": 0.88, + "content": "0 . 7 9 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 720, + 411, + 733 + ], + "score": 1.0, + "content": "with 50 steps (see Figure 2).", + "type": "text" + } + ], + "index": 71 + } + ], + "index": 70.5, + "bbox_fs": [ + 105, + 707, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 506, + 95 + ], + "score": 1.0, + "content": "Once the average simulated staleness was chosen to be more than 15 steps, the results started to", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 107 + ], + "score": 1.0, + "content": "significantly deteriorate and the training itself became much less stable. We had to employ following", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 104, + 288, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 104, + 288, + 118 + ], + "score": 1.0, + "content": "tricks to prevent the results from blowing up:", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 132, + 127, + 505, + 264 + ], + "lines": [ + { + "bbox": [ + 133, + 127, + 505, + 141 + ], + "spans": [ + { + "bbox": [ + 133, + 127, + 505, + 141 + ], + "score": 1.0, + "content": "• Slowly increase the staleness over the first 3 epochs of training. This mimics increasing", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 142, + 139, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 142, + 139, + 505, + 150 + ], + "score": 1.0, + "content": "the number of asynchronous workers and is also very important in practice for some of the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 141, + 150, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 141, + 150, + 505, + 163 + ], + "score": 1.0, + "content": "models we experimented with (e.g. large word-level language models). The trick was not", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 160, + 479, + 173 + ], + "spans": [ + { + "bbox": [ + 141, + 160, + 479, + 173 + ], + "score": 1.0, + "content": "relevant with a simulated staleness less than 15 but became crucial for larger values.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 179, + 506, + 192 + ], + "spans": [ + { + "bbox": [ + 141, + 179, + 506, + 192 + ], + "score": 1.0, + "content": "Use lower initial learning rates when staleness is at least 20, which reduces a frequency of", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 190, + 506, + 202 + ], + "spans": [ + { + "bbox": [ + 141, + 190, + 264, + 202 + ], + "score": 1.0, + "content": "explosions (train error goes to", + "type": "text" + }, + { + "bbox": [ + 264, + 190, + 284, + 201 + ], + "score": 0.86, + "content": "90 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 190, + 506, + 202 + ], + "score": 1.0, + "content": "). This observation is similar to what we found in other", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 201, + 505, + 215 + ], + "spans": [ + { + "bbox": [ + 141, + 201, + 505, + 215 + ], + "score": 1.0, + "content": "experiments - we were able to use much larger learning rates with synchronous training", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 142, + 213, + 294, + 223 + ], + "spans": [ + { + "bbox": [ + 142, + 213, + 294, + 223 + ], + "score": 1.0, + "content": "and the results were also more stable.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 139, + 230, + 505, + 244 + ], + "spans": [ + { + "bbox": [ + 139, + 230, + 505, + 244 + ], + "score": 1.0, + "content": "Even with above tricks the divergence occurs occasionally and we found that restarting", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 142, + 243, + 505, + 254 + ], + "spans": [ + { + "bbox": [ + 142, + 243, + 505, + 254 + ], + "score": 1.0, + "content": "training from random weights can lead to more successful runs. The best results were then", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 142, + 253, + 321, + 266 + ], + "spans": [ + { + "bbox": [ + 142, + 253, + 321, + 266 + ], + "score": 1.0, + "content": "chosen based on validation set performance.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 8 + }, + { + "type": "title", + "bbox": [ + 108, + 284, + 414, + 298 + ], + "lines": [ + { + "bbox": [ + 105, + 283, + 416, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 283, + 416, + 300 + ], + "score": 1.0, + "content": "3 REVISTING SYNCHRONOUS STOCHASTIC OPTIMIZATION", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 312, + 505, + 401 + ], + "lines": [ + { + "bbox": [ + 105, + 312, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 312, + 505, + 326 + ], + "score": 1.0, + "content": "Both Dean et al. (2012) and Chilimbi et al. (2014) use versions of Async-SGD where the main po-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 323, + 505, + 336 + ], + "spans": [ + { + "bbox": [ + 105, + 323, + 505, + 336 + ], + "score": 1.0, + "content": "tential problem is that each worker computes gradients over a potentially old version of the model.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 334, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 505, + 347 + ], + "score": 1.0, + "content": "In order to remove this discrepancy, we propose here to reconsider a synchronous version of dis-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 345, + 505, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 505, + 358 + ], + "score": 1.0, + "content": "tributed stochastic gradient descent (Sync-SGD), or more generally, Synchronous Stochastic Op-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 356, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 505, + 369 + ], + "score": 1.0, + "content": "timization (Sync-Opt), where the parameter servers wait for all workers to send their gradients,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 368, + 506, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 368, + 506, + 380 + ], + "score": 1.0, + "content": "aggregate them, and send the updated parameters to all workers afterward. This ensures that the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 379, + 506, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 379, + 506, + 391 + ], + "score": 1.0, + "content": "actual algorithm is a true mini-batch stochastic gradient descent, with an effective batch size equal", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 390, + 318, + 401 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 318, + 401 + ], + "score": 1.0, + "content": "to the sum of all the mini-batch sizes of the workers.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 18.5 + }, + { + "type": "text", + "bbox": [ + 107, + 406, + 504, + 461 + ], + "lines": [ + { + "bbox": [ + 106, + 405, + 506, + 419 + ], + "spans": [ + { + "bbox": [ + 106, + 405, + 506, + 419 + ], + "score": 1.0, + "content": "While this approach solves the staleness problem, it also introduces the potential problem that the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 416, + 505, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 505, + 430 + ], + "score": 1.0, + "content": "actual update time now depends on the slowest worker. Although workers have equivalent compu-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 428, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 506, + 442 + ], + "score": 1.0, + "content": "tation and network communication workload, slow stragglers may result from failing hardware, or", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 439, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 505, + 453 + ], + "score": 1.0, + "content": "contention on shared underlying hardware resources in data centers, or even due to preemption by", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 450, + 151, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 151, + 463 + ], + "score": 1.0, + "content": "other jobs.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 467, + 505, + 522 + ], + "lines": [ + { + "bbox": [ + 106, + 466, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 505, + 480 + ], + "score": 1.0, + "content": "To alleviate the straggler problem, we introduce backup workers (Dean & Barroso, 2013) as follows:", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 478, + 505, + 490 + ], + "spans": [ + { + "bbox": [ + 106, + 478, + 201, + 490 + ], + "score": 1.0, + "content": "instead of having only", + "type": "text" + }, + { + "bbox": [ + 201, + 479, + 212, + 488 + ], + "score": 0.78, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 478, + 284, + 490 + ], + "score": 1.0, + "content": "workers, we add", + "type": "text" + }, + { + "bbox": [ + 285, + 479, + 291, + 488 + ], + "score": 0.49, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 291, + 478, + 505, + 490 + ], + "score": 1.0, + "content": "extra workers, but as soon as the parameter servers", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 489, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 220, + 501 + ], + "score": 1.0, + "content": "receive gradients from any", + "type": "text" + }, + { + "bbox": [ + 220, + 489, + 231, + 499 + ], + "score": 0.77, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 489, + 505, + 501 + ], + "score": 1.0, + "content": "workers, they stop waiting and update their parameters using the", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 500, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 117, + 510 + ], + "score": 0.74, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 500, + 214, + 513 + ], + "score": 1.0, + "content": "gradients. The slowest", + "type": "text" + }, + { + "bbox": [ + 215, + 501, + 221, + 510 + ], + "score": 0.45, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 221, + 500, + 505, + 513 + ], + "score": 1.0, + "content": "workers’ gradients will be dropped when they arrive. Our method is", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 511, + 225, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 225, + 523 + ], + "score": 1.0, + "content": "presented in Algorithms 3, 4.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30 + }, + { + "type": "title", + "bbox": [ + 106, + 542, + 300, + 564 + ], + "lines": [ + { + "bbox": [ + 106, + 541, + 302, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 541, + 243, + 554 + ], + "score": 1.0, + "content": "Algorithm 3: Sync-SGD worker", + "type": "text" + }, + { + "bbox": [ + 243, + 543, + 250, + 552 + ], + "score": 0.69, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 541, + 282, + 554 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 282, + 542, + 302, + 552 + ], + "score": 0.76, + "content": "k =", + "type": "inline_equation" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 553, + 162, + 564 + ], + "spans": [ + { + "bbox": [ + 106, + 553, + 162, + 564 + ], + "score": 0.51, + "content": "1 , \\ldots , N + b", + "type": "inline_equation" + } + ], + "index": 34 + } + ], + "index": 33.5 + }, + { + "type": "text", + "bbox": [ + 98, + 566, + 297, + 702 + ], + "lines": [ + { + "bbox": [ + 106, + 566, + 171, + 577 + ], + "spans": [ + { + "bbox": [ + 106, + 566, + 162, + 577 + ], + "score": 1.0, + "content": "Input: Dataset", + "type": "text" + }, + { + "bbox": [ + 162, + 567, + 171, + 576 + ], + "score": 0.59, + "content": "\\mathcal { X }", + "type": "inline_equation" + } + ], + "index": 35 + }, + { + "bbox": [ + 104, + 576, + 200, + 587 + ], + "spans": [ + { + "bbox": [ + 104, + 576, + 132, + 587 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 133, + 577, + 141, + 586 + ], + "score": 0.74, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 576, + 200, + 587 + ], + "score": 1.0, + "content": "mini-batch size", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 97, + 586, + 181, + 597 + ], + "spans": [ + { + "bbox": [ + 97, + 586, + 120, + 596 + ], + "score": 1.0, + "content": "1 for", + "type": "text" + }, + { + "bbox": [ + 120, + 587, + 165, + 597 + ], + "score": 0.82, + "content": "t = 0 , 1 , \\ldots", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 586, + 181, + 596 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 97, + 593, + 274, + 610 + ], + "spans": [ + { + "bbox": [ + 97, + 599, + 105, + 608 + ], + "score": 1.0, + "content": "2", + "type": "text" + }, + { + "bbox": [ + 119, + 593, + 168, + 610 + ], + "score": 1.0, + "content": "Wait to read", + "type": "text" + }, + { + "bbox": [ + 168, + 596, + 274, + 609 + ], + "score": 0.89, + "content": "{ \\boldsymbol { \\theta } } ^ { ( t ) } = ( { \\boldsymbol { \\theta } } ^ { ( t ) } [ 0 ] , \\dots , { \\boldsymbol { \\theta } } ^ { ( t ) } [ M ] )", + "type": "inline_equation" + } + ], + "index": 38 + }, + { + "bbox": [ + 121, + 606, + 210, + 619 + ], + "spans": [ + { + "bbox": [ + 121, + 606, + 210, + 619 + ], + "score": 1.0, + "content": "from parameter servers.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 97, + 618, + 160, + 632 + ], + "spans": [ + { + "bbox": [ + 97, + 622, + 105, + 631 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 122, + 618, + 160, + 632 + ], + "score": 0.46, + "content": "G _ { k } ^ { ( t ) } : = 0", + "type": "inline_equation" + } + ], + "index": 41 + }, + { + "bbox": [ + 97, + 630, + 198, + 641 + ], + "spans": [ + { + "bbox": [ + 97, + 632, + 105, + 641 + ], + "score": 1.0, + "content": "4", + "type": "text" + }, + { + "bbox": [ + 120, + 630, + 136, + 641 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 136, + 631, + 185, + 641 + ], + "score": 0.71, + "content": "i = 1 , \\ldots , B", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 630, + 198, + 641 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 97, + 640, + 251, + 651 + ], + "spans": [ + { + "bbox": [ + 97, + 642, + 104, + 651 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 136, + 640, + 201, + 651 + ], + "score": 1.0, + "content": "Sample datapoint", + "type": "text" + }, + { + "bbox": [ + 202, + 641, + 218, + 651 + ], + "score": 0.87, + "content": "\\widetilde { x } _ { k , i }", + "type": "inline_equation" + }, + { + "bbox": [ + 218, + 640, + 239, + 651 + ], + "score": 1.0, + "content": "from", + "type": "text" + }, + { + "bbox": [ + 239, + 641, + 248, + 650 + ], + "score": 0.76, + "content": "\\mathcal { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 640, + 251, + 651 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 97, + 648, + 264, + 669 + ], + "spans": [ + { + "bbox": [ + 97, + 655, + 105, + 664 + ], + "score": 1.0, + "content": "6", + "type": "text" + }, + { + "bbox": [ + 134, + 648, + 137, + 669 + ], + "score": 0.0, + "content": "", + "type": "text" + }, + { + "bbox": [ + 137, + 651, + 260, + 666 + ], + "score": 0.78, + "content": "\\begin{array} { r } { G _ { k } ^ { ( t ) } G _ { k } ^ { ( t ) } + \\frac { 1 } { B } \\nabla F ( \\widetilde { x } _ { k , i } ; \\theta ^ { ( t ) } ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 648, + 264, + 669 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 97, + 663, + 139, + 675 + ], + "spans": [ + { + "bbox": [ + 97, + 667, + 104, + 675 + ], + "score": 1.0, + "content": "7", + "type": "text" + }, + { + "bbox": [ + 119, + 663, + 139, + 675 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 97, + 674, + 254, + 691 + ], + "spans": [ + { + "bbox": [ + 97, + 678, + 105, + 688 + ], + "score": 1.0, + "content": "8", + "type": "text" + }, + { + "bbox": [ + 119, + 674, + 142, + 691 + ], + "score": 1.0, + "content": "Send", + "type": "text" + }, + { + "bbox": [ + 143, + 675, + 174, + 689 + ], + "score": 0.89, + "content": "( G _ { k } ^ { ( t ) } , t )", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 674, + 254, + 691 + ], + "score": 1.0, + "content": "to parameter servers.", + "type": "text" + } + ], + "index": 57 + }, + { + "bbox": [ + 97, + 688, + 124, + 699 + ], + "spans": [ + { + "bbox": [ + 97, + 690, + 106, + 699 + ], + "score": 1.0, + "content": "9", + "type": "text" + }, + { + "bbox": [ + 103, + 688, + 124, + 699 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 58 + } + ], + "index": 40.5 + }, + { + "type": "title", + "bbox": [ + 311, + 542, + 488, + 553 + ], + "lines": [ + { + "bbox": [ + 309, + 541, + 489, + 556 + ], + "spans": [ + { + "bbox": [ + 309, + 541, + 483, + 556 + ], + "score": 1.0, + "content": "Algorithm 4: Sync-SGD Parameter Server", + "type": "text" + }, + { + "bbox": [ + 484, + 543, + 489, + 554 + ], + "score": 0.41, + "content": "j", + "type": "inline_equation" + } + ], + "index": 48 + } + ], + "index": 48 + }, + { + "type": "text", + "bbox": [ + 302, + 556, + 482, + 705 + ], + "lines": [ + { + "bbox": [ + 309, + 555, + 429, + 568 + ], + "spans": [ + { + "bbox": [ + 309, + 555, + 335, + 568 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 335, + 558, + 374, + 566 + ], + "score": 0.67, + "content": "\\gamma _ { 0 } , \\gamma _ { 1 } , \\ldots", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 555, + 429, + 568 + ], + "score": 1.0, + "content": "learning rates.", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 308, + 565, + 385, + 577 + ], + "spans": [ + { + "bbox": [ + 308, + 565, + 335, + 577 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 336, + 568, + 343, + 575 + ], + "score": 0.7, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 565, + 385, + 577 + ], + "score": 1.0, + "content": "decay rate.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 308, + 575, + 482, + 587 + ], + "spans": [ + { + "bbox": [ + 308, + 575, + 335, + 587 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 336, + 576, + 345, + 585 + ], + "score": 0.75, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 345, + 575, + 482, + 587 + ], + "score": 1.0, + "content": "number of mini-batches to aggregate.", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 308, + 585, + 428, + 598 + ], + "spans": [ + { + "bbox": [ + 308, + 585, + 335, + 598 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 336, + 585, + 351, + 596 + ], + "score": 0.86, + "content": "\\theta ^ { ( 0 ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 585, + 428, + 598 + ], + "score": 1.0, + "content": "model initialization.", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 307, + 596, + 384, + 608 + ], + "spans": [ + { + "bbox": [ + 307, + 596, + 323, + 608 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 323, + 597, + 367, + 607 + ], + "score": 0.85, + "content": "t = 0 , 1 , \\ldots", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 596, + 384, + 608 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 301, + 607, + 354, + 618 + ], + "spans": [ + { + "bbox": [ + 301, + 609, + 307, + 616 + ], + "score": 1.0, + "content": "2", + "type": "text" + }, + { + "bbox": [ + 324, + 607, + 354, + 618 + ], + "score": 0.68, + "content": "\\mathcal { G } = \\{ \\}", + "type": "inline_equation" + } + ], + "index": 51 + }, + { + "bbox": [ + 301, + 616, + 393, + 627 + ], + "spans": [ + { + "bbox": [ + 301, + 619, + 307, + 626 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 325, + 616, + 348, + 627 + ], + "score": 1.0, + "content": "while", + "type": "text" + }, + { + "bbox": [ + 348, + 617, + 380, + 627 + ], + "score": 0.87, + "content": "| \\mathcal { G } | < N", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 616, + 393, + 627 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 300, + 626, + 462, + 638 + ], + "spans": [ + { + "bbox": [ + 300, + 629, + 308, + 637 + ], + "score": 1.0, + "content": "4", + "type": "text" + }, + { + "bbox": [ + 339, + 626, + 372, + 638 + ], + "score": 1.0, + "content": "Wait for", + "type": "text" + }, + { + "bbox": [ + 372, + 627, + 397, + 637 + ], + "score": 0.91, + "content": "( G , t ^ { \\prime } )", + "type": "inline_equation" + }, + { + "bbox": [ + 398, + 626, + 462, + 638 + ], + "score": 1.0, + "content": "from any worker.", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 301, + 636, + 456, + 650 + ], + "spans": [ + { + "bbox": [ + 301, + 641, + 307, + 648 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 339, + 636, + 348, + 650 + ], + "score": 1.0, + "content": "if", + "type": "text" + }, + { + "bbox": [ + 348, + 637, + 378, + 647 + ], + "score": 0.88, + "content": "t ^ { \\prime } = = t", + "type": "inline_equation" + }, + { + "bbox": [ + 378, + 636, + 398, + 650 + ], + "score": 1.0, + "content": "then", + "type": "text" + }, + { + "bbox": [ + 398, + 638, + 452, + 649 + ], + "score": 0.91, + "content": "{ \\mathcal { G } } { \\mathcal { G } } \\cup \\{ G \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 636, + 456, + 650 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 301, + 646, + 421, + 660 + ], + "spans": [ + { + "bbox": [ + 301, + 651, + 307, + 657 + ], + "score": 1.0, + "content": "6", + "type": "text" + }, + { + "bbox": [ + 339, + 646, + 408, + 660 + ], + "score": 1.0, + "content": "else Drop gradient", + "type": "text" + }, + { + "bbox": [ + 409, + 649, + 417, + 657 + ], + "score": 0.76, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 646, + 421, + 660 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 55 + }, + { + "bbox": [ + 301, + 659, + 342, + 669 + ], + "spans": [ + { + "bbox": [ + 301, + 661, + 307, + 669 + ], + "score": 1.0, + "content": "7", + "type": "text" + }, + { + "bbox": [ + 324, + 659, + 342, + 669 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 56 + }, + { + "bbox": [ + 301, + 669, + 465, + 696 + ], + "spans": [ + { + "bbox": [ + 301, + 674, + 307, + 681 + ], + "score": 1.0, + "content": "8", + "type": "text" + }, + { + "bbox": [ + 323, + 669, + 465, + 696 + ], + "score": 0.51, + "content": "\\begin{array} { r } { \\theta ^ { ( t + 1 ) } [ j ] \\theta ^ { ( t ) } [ j ] - \\frac { \\gamma _ { t } } { N } \\sum _ { G \\in \\mathcal { G } } G [ j ] . } \\\\ { \\bar { \\theta } ^ { ( t ) } [ j ] = \\alpha \\bar { \\theta } ^ { ( t - 1 ) } [ j ] + ( 1 - \\alpha ) \\theta ^ { ( t ) } [ j ] . } \\end{array}", + "type": "inline_equation", + "image_path": "862e557fb9bf8b86646596455d0a5a7d5bad24105cdbbc6c579c2f59b82d1861.jpg" + } + ], + "index": 60 + }, + { + "bbox": [ + 301, + 686, + 307, + 693 + ], + "spans": [ + { + "bbox": [ + 301, + 686, + 307, + 693 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ], + "index": 59 + }, + { + "bbox": [ + 301, + 694, + 326, + 704 + ], + "spans": [ + { + "bbox": [ + 301, + 697, + 308, + 704 + ], + "score": 1.0, + "content": "10", + "type": "text" + }, + { + "bbox": [ + 307, + 694, + 326, + 704 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 61 + } + ], + "index": 52.5 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 25, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 25, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 759 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "4", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 506, + 95 + ], + "score": 1.0, + "content": "Once the average simulated staleness was chosen to be more than 15 steps, the results started to", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 107 + ], + "score": 1.0, + "content": "significantly deteriorate and the training itself became much less stable. We had to employ following", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 104, + 288, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 104, + 288, + 118 + ], + "score": 1.0, + "content": "tricks to prevent the results from blowing up:", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 105, + 82, + 506, + 118 + ] + }, + { + "type": "list", + "bbox": [ + 132, + 127, + 505, + 264 + ], + "lines": [ + { + "bbox": [ + 133, + 127, + 505, + 141 + ], + "spans": [ + { + "bbox": [ + 133, + 127, + 505, + 141 + ], + "score": 1.0, + "content": "• Slowly increase the staleness over the first 3 epochs of training. This mimics increasing", + "type": "text" + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 142, + 139, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 142, + 139, + 505, + 150 + ], + "score": 1.0, + "content": "the number of asynchronous workers and is also very important in practice for some of the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 141, + 150, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 141, + 150, + 505, + 163 + ], + "score": 1.0, + "content": "models we experimented with (e.g. large word-level language models). The trick was not", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 160, + 479, + 173 + ], + "spans": [ + { + "bbox": [ + 141, + 160, + 479, + 173 + ], + "score": 1.0, + "content": "relevant with a simulated staleness less than 15 but became crucial for larger values.", + "type": "text" + } + ], + "index": 6, + "is_list_end_line": true + }, + { + "bbox": [ + 141, + 179, + 506, + 192 + ], + "spans": [ + { + "bbox": [ + 141, + 179, + 506, + 192 + ], + "score": 1.0, + "content": "Use lower initial learning rates when staleness is at least 20, which reduces a frequency of", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 190, + 506, + 202 + ], + "spans": [ + { + "bbox": [ + 141, + 190, + 264, + 202 + ], + "score": 1.0, + "content": "explosions (train error goes to", + "type": "text" + }, + { + "bbox": [ + 264, + 190, + 284, + 201 + ], + "score": 0.86, + "content": "90 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 190, + 506, + 202 + ], + "score": 1.0, + "content": "). This observation is similar to what we found in other", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 201, + 505, + 215 + ], + "spans": [ + { + "bbox": [ + 141, + 201, + 505, + 215 + ], + "score": 1.0, + "content": "experiments - we were able to use much larger learning rates with synchronous training", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 142, + 213, + 294, + 223 + ], + "spans": [ + { + "bbox": [ + 142, + 213, + 294, + 223 + ], + "score": 1.0, + "content": "and the results were also more stable.", + "type": "text" + } + ], + "index": 10, + "is_list_end_line": true + }, + { + "bbox": [ + 139, + 230, + 505, + 244 + ], + "spans": [ + { + "bbox": [ + 139, + 230, + 505, + 244 + ], + "score": 1.0, + "content": "Even with above tricks the divergence occurs occasionally and we found that restarting", + "type": "text" + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 142, + 243, + 505, + 254 + ], + "spans": [ + { + "bbox": [ + 142, + 243, + 505, + 254 + ], + "score": 1.0, + "content": "training from random weights can lead to more successful runs. The best results were then", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 142, + 253, + 321, + 266 + ], + "spans": [ + { + "bbox": [ + 142, + 253, + 321, + 266 + ], + "score": 1.0, + "content": "chosen based on validation set performance.", + "type": "text" + } + ], + "index": 13, + "is_list_end_line": true + } + ], + "index": 8, + "bbox_fs": [ + 133, + 127, + 506, + 266 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 284, + 414, + 298 + ], + "lines": [ + { + "bbox": [ + 105, + 283, + 416, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 283, + 416, + 300 + ], + "score": 1.0, + "content": "3 REVISTING SYNCHRONOUS STOCHASTIC OPTIMIZATION", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 312, + 505, + 401 + ], + "lines": [ + { + "bbox": [ + 105, + 312, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 312, + 505, + 326 + ], + "score": 1.0, + "content": "Both Dean et al. (2012) and Chilimbi et al. (2014) use versions of Async-SGD where the main po-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 323, + 505, + 336 + ], + "spans": [ + { + "bbox": [ + 105, + 323, + 505, + 336 + ], + "score": 1.0, + "content": "tential problem is that each worker computes gradients over a potentially old version of the model.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 334, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 505, + 347 + ], + "score": 1.0, + "content": "In order to remove this discrepancy, we propose here to reconsider a synchronous version of dis-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 345, + 505, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 505, + 358 + ], + "score": 1.0, + "content": "tributed stochastic gradient descent (Sync-SGD), or more generally, Synchronous Stochastic Op-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 356, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 505, + 369 + ], + "score": 1.0, + "content": "timization (Sync-Opt), where the parameter servers wait for all workers to send their gradients,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 368, + 506, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 368, + 506, + 380 + ], + "score": 1.0, + "content": "aggregate them, and send the updated parameters to all workers afterward. This ensures that the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 379, + 506, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 379, + 506, + 391 + ], + "score": 1.0, + "content": "actual algorithm is a true mini-batch stochastic gradient descent, with an effective batch size equal", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 390, + 318, + 401 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 318, + 401 + ], + "score": 1.0, + "content": "to the sum of all the mini-batch sizes of the workers.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 18.5, + "bbox_fs": [ + 105, + 312, + 506, + 401 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 406, + 504, + 461 + ], + "lines": [ + { + "bbox": [ + 106, + 405, + 506, + 419 + ], + "spans": [ + { + "bbox": [ + 106, + 405, + 506, + 419 + ], + "score": 1.0, + "content": "While this approach solves the staleness problem, it also introduces the potential problem that the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 416, + 505, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 505, + 430 + ], + "score": 1.0, + "content": "actual update time now depends on the slowest worker. Although workers have equivalent compu-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 428, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 506, + 442 + ], + "score": 1.0, + "content": "tation and network communication workload, slow stragglers may result from failing hardware, or", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 439, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 505, + 453 + ], + "score": 1.0, + "content": "contention on shared underlying hardware resources in data centers, or even due to preemption by", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 450, + 151, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 151, + 463 + ], + "score": 1.0, + "content": "other jobs.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 405, + 506, + 463 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 467, + 505, + 522 + ], + "lines": [ + { + "bbox": [ + 106, + 466, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 505, + 480 + ], + "score": 1.0, + "content": "To alleviate the straggler problem, we introduce backup workers (Dean & Barroso, 2013) as follows:", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 478, + 505, + 490 + ], + "spans": [ + { + "bbox": [ + 106, + 478, + 201, + 490 + ], + "score": 1.0, + "content": "instead of having only", + "type": "text" + }, + { + "bbox": [ + 201, + 479, + 212, + 488 + ], + "score": 0.78, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 478, + 284, + 490 + ], + "score": 1.0, + "content": "workers, we add", + "type": "text" + }, + { + "bbox": [ + 285, + 479, + 291, + 488 + ], + "score": 0.49, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 291, + 478, + 505, + 490 + ], + "score": 1.0, + "content": "extra workers, but as soon as the parameter servers", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 489, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 220, + 501 + ], + "score": 1.0, + "content": "receive gradients from any", + "type": "text" + }, + { + "bbox": [ + 220, + 489, + 231, + 499 + ], + "score": 0.77, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 489, + 505, + 501 + ], + "score": 1.0, + "content": "workers, they stop waiting and update their parameters using the", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 500, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 117, + 510 + ], + "score": 0.74, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 500, + 214, + 513 + ], + "score": 1.0, + "content": "gradients. The slowest", + "type": "text" + }, + { + "bbox": [ + 215, + 501, + 221, + 510 + ], + "score": 0.45, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 221, + 500, + 505, + 513 + ], + "score": 1.0, + "content": "workers’ gradients will be dropped when they arrive. Our method is", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 511, + 225, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 225, + 523 + ], + "score": 1.0, + "content": "presented in Algorithms 3, 4.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30, + "bbox_fs": [ + 105, + 466, + 505, + 523 + ] + }, + { + "type": "title", + "bbox": [ + 106, + 542, + 300, + 564 + ], + "lines": [ + { + "bbox": [ + 106, + 541, + 302, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 541, + 243, + 554 + ], + "score": 1.0, + "content": "Algorithm 3: Sync-SGD worker", + "type": "text" + }, + { + "bbox": [ + 243, + 543, + 250, + 552 + ], + "score": 0.69, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 541, + 282, + 554 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 282, + 542, + 302, + 552 + ], + "score": 0.76, + "content": "k =", + "type": "inline_equation" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 553, + 162, + 564 + ], + "spans": [ + { + "bbox": [ + 106, + 553, + 162, + 564 + ], + "score": 0.51, + "content": "1 , \\ldots , N + b", + "type": "inline_equation" + } + ], + "index": 34 + } + ], + "index": 33.5 + }, + { + "type": "text", + "bbox": [ + 98, + 566, + 297, + 702 + ], + "lines": [ + { + "bbox": [ + 106, + 566, + 171, + 577 + ], + "spans": [ + { + "bbox": [ + 106, + 566, + 162, + 577 + ], + "score": 1.0, + "content": "Input: Dataset", + "type": "text" + }, + { + "bbox": [ + 162, + 567, + 171, + 576 + ], + "score": 0.59, + "content": "\\mathcal { X }", + "type": "inline_equation" + } + ], + "index": 35 + }, + { + "bbox": [ + 104, + 576, + 200, + 587 + ], + "spans": [ + { + "bbox": [ + 104, + 576, + 132, + 587 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 133, + 577, + 141, + 586 + ], + "score": 0.74, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 576, + 200, + 587 + ], + "score": 1.0, + "content": "mini-batch size", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 97, + 586, + 181, + 597 + ], + "spans": [ + { + "bbox": [ + 97, + 586, + 120, + 596 + ], + "score": 1.0, + "content": "1 for", + "type": "text" + }, + { + "bbox": [ + 120, + 587, + 165, + 597 + ], + "score": 0.82, + "content": "t = 0 , 1 , \\ldots", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 586, + 181, + 596 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 97, + 593, + 274, + 610 + ], + "spans": [ + { + "bbox": [ + 97, + 599, + 105, + 608 + ], + "score": 1.0, + "content": "2", + "type": "text" + }, + { + "bbox": [ + 119, + 593, + 168, + 610 + ], + "score": 1.0, + "content": "Wait to read", + "type": "text" + }, + { + "bbox": [ + 168, + 596, + 274, + 609 + ], + "score": 0.89, + "content": "{ \\boldsymbol { \\theta } } ^ { ( t ) } = ( { \\boldsymbol { \\theta } } ^ { ( t ) } [ 0 ] , \\dots , { \\boldsymbol { \\theta } } ^ { ( t ) } [ M ] )", + "type": "inline_equation" + } + ], + "index": 38 + }, + { + "bbox": [ + 121, + 606, + 210, + 619 + ], + "spans": [ + { + "bbox": [ + 121, + 606, + 210, + 619 + ], + "score": 1.0, + "content": "from parameter servers.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 97, + 618, + 160, + 632 + ], + "spans": [ + { + "bbox": [ + 97, + 622, + 105, + 631 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 122, + 618, + 160, + 632 + ], + "score": 0.46, + "content": "G _ { k } ^ { ( t ) } : = 0", + "type": "inline_equation" + } + ], + "index": 41 + }, + { + "bbox": [ + 97, + 630, + 198, + 641 + ], + "spans": [ + { + "bbox": [ + 97, + 632, + 105, + 641 + ], + "score": 1.0, + "content": "4", + "type": "text" + }, + { + "bbox": [ + 120, + 630, + 136, + 641 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 136, + 631, + 185, + 641 + ], + "score": 0.71, + "content": "i = 1 , \\ldots , B", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 630, + 198, + 641 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 97, + 640, + 251, + 651 + ], + "spans": [ + { + "bbox": [ + 97, + 642, + 104, + 651 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 136, + 640, + 201, + 651 + ], + "score": 1.0, + "content": "Sample datapoint", + "type": "text" + }, + { + "bbox": [ + 202, + 641, + 218, + 651 + ], + "score": 0.87, + "content": "\\widetilde { x } _ { k , i }", + "type": "inline_equation" + }, + { + "bbox": [ + 218, + 640, + 239, + 651 + ], + "score": 1.0, + "content": "from", + "type": "text" + }, + { + "bbox": [ + 239, + 641, + 248, + 650 + ], + "score": 0.76, + "content": "\\mathcal { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 640, + 251, + 651 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 97, + 648, + 264, + 669 + ], + "spans": [ + { + "bbox": [ + 97, + 655, + 105, + 664 + ], + "score": 1.0, + "content": "6", + "type": "text" + }, + { + "bbox": [ + 134, + 648, + 137, + 669 + ], + "score": 0.0, + "content": "", + "type": "text" + }, + { + "bbox": [ + 137, + 651, + 260, + 666 + ], + "score": 0.78, + "content": "\\begin{array} { r } { G _ { k } ^ { ( t ) } G _ { k } ^ { ( t ) } + \\frac { 1 } { B } \\nabla F ( \\widetilde { x } _ { k , i } ; \\theta ^ { ( t ) } ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 648, + 264, + 669 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 97, + 663, + 139, + 675 + ], + "spans": [ + { + "bbox": [ + 97, + 667, + 104, + 675 + ], + "score": 1.0, + "content": "7", + "type": "text" + }, + { + "bbox": [ + 119, + 663, + 139, + 675 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 97, + 674, + 254, + 691 + ], + "spans": [ + { + "bbox": [ + 97, + 678, + 105, + 688 + ], + "score": 1.0, + "content": "8", + "type": "text" + }, + { + "bbox": [ + 119, + 674, + 142, + 691 + ], + "score": 1.0, + "content": "Send", + "type": "text" + }, + { + "bbox": [ + 143, + 675, + 174, + 689 + ], + "score": 0.89, + "content": "( G _ { k } ^ { ( t ) } , t )", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 674, + 254, + 691 + ], + "score": 1.0, + "content": "to parameter servers.", + "type": "text" + } + ], + "index": 57 + }, + { + "bbox": [ + 97, + 688, + 124, + 699 + ], + "spans": [ + { + "bbox": [ + 97, + 690, + 106, + 699 + ], + "score": 1.0, + "content": "9", + "type": "text" + }, + { + "bbox": [ + 103, + 688, + 124, + 699 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 58 + } + ], + "index": 40.5, + "bbox_fs": [ + 97, + 566, + 274, + 699 + ] + }, + { + "type": "title", + "bbox": [ + 311, + 542, + 488, + 553 + ], + "lines": [ + { + "bbox": [ + 309, + 541, + 489, + 556 + ], + "spans": [ + { + "bbox": [ + 309, + 541, + 483, + 556 + ], + "score": 1.0, + "content": "Algorithm 4: Sync-SGD Parameter Server", + "type": "text" + }, + { + "bbox": [ + 484, + 543, + 489, + 554 + ], + "score": 0.41, + "content": "j", + "type": "inline_equation" + } + ], + "index": 48 + } + ], + "index": 48 + }, + { + "type": "text", + "bbox": [ + 302, + 556, + 482, + 705 + ], + "lines": [ + { + "bbox": [ + 309, + 555, + 429, + 568 + ], + "spans": [ + { + "bbox": [ + 309, + 555, + 335, + 568 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 335, + 558, + 374, + 566 + ], + "score": 0.67, + "content": "\\gamma _ { 0 } , \\gamma _ { 1 } , \\ldots", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 555, + 429, + 568 + ], + "score": 1.0, + "content": "learning rates.", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 308, + 565, + 385, + 577 + ], + "spans": [ + { + "bbox": [ + 308, + 565, + 335, + 577 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 336, + 568, + 343, + 575 + ], + "score": 0.7, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 565, + 385, + 577 + ], + "score": 1.0, + "content": "decay rate.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 308, + 575, + 482, + 587 + ], + "spans": [ + { + "bbox": [ + 308, + 575, + 335, + 587 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 336, + 576, + 345, + 585 + ], + "score": 0.75, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 345, + 575, + 482, + 587 + ], + "score": 1.0, + "content": "number of mini-batches to aggregate.", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 308, + 585, + 428, + 598 + ], + "spans": [ + { + "bbox": [ + 308, + 585, + 335, + 598 + ], + "score": 1.0, + "content": "Input:", + "type": "text" + }, + { + "bbox": [ + 336, + 585, + 351, + 596 + ], + "score": 0.86, + "content": "\\theta ^ { ( 0 ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 585, + 428, + 598 + ], + "score": 1.0, + "content": "model initialization.", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 307, + 596, + 384, + 608 + ], + "spans": [ + { + "bbox": [ + 307, + 596, + 323, + 608 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 323, + 597, + 367, + 607 + ], + "score": 0.85, + "content": "t = 0 , 1 , \\ldots", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 596, + 384, + 608 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 301, + 607, + 354, + 618 + ], + "spans": [ + { + "bbox": [ + 301, + 609, + 307, + 616 + ], + "score": 1.0, + "content": "2", + "type": "text" + }, + { + "bbox": [ + 324, + 607, + 354, + 618 + ], + "score": 0.68, + "content": "\\mathcal { G } = \\{ \\}", + "type": "inline_equation" + } + ], + "index": 51 + }, + { + "bbox": [ + 301, + 616, + 393, + 627 + ], + "spans": [ + { + "bbox": [ + 301, + 619, + 307, + 626 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 325, + 616, + 348, + 627 + ], + "score": 1.0, + "content": "while", + "type": "text" + }, + { + "bbox": [ + 348, + 617, + 380, + 627 + ], + "score": 0.87, + "content": "| \\mathcal { G } | < N", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 616, + 393, + 627 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 300, + 626, + 462, + 638 + ], + "spans": [ + { + "bbox": [ + 300, + 629, + 308, + 637 + ], + "score": 1.0, + "content": "4", + "type": "text" + }, + { + "bbox": [ + 339, + 626, + 372, + 638 + ], + "score": 1.0, + "content": "Wait for", + "type": "text" + }, + { + "bbox": [ + 372, + 627, + 397, + 637 + ], + "score": 0.91, + "content": "( G , t ^ { \\prime } )", + "type": "inline_equation" + }, + { + "bbox": [ + 398, + 626, + 462, + 638 + ], + "score": 1.0, + "content": "from any worker.", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 301, + 636, + 456, + 650 + ], + "spans": [ + { + "bbox": [ + 301, + 641, + 307, + 648 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 339, + 636, + 348, + 650 + ], + "score": 1.0, + "content": "if", + "type": "text" + }, + { + "bbox": [ + 348, + 637, + 378, + 647 + ], + "score": 0.88, + "content": "t ^ { \\prime } = = t", + "type": "inline_equation" + }, + { + "bbox": [ + 378, + 636, + 398, + 650 + ], + "score": 1.0, + "content": "then", + "type": "text" + }, + { + "bbox": [ + 398, + 638, + 452, + 649 + ], + "score": 0.91, + "content": "{ \\mathcal { G } } { \\mathcal { G } } \\cup \\{ G \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 636, + 456, + 650 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 301, + 646, + 421, + 660 + ], + "spans": [ + { + "bbox": [ + 301, + 651, + 307, + 657 + ], + "score": 1.0, + "content": "6", + "type": "text" + }, + { + "bbox": [ + 339, + 646, + 408, + 660 + ], + "score": 1.0, + "content": "else Drop gradient", + "type": "text" + }, + { + "bbox": [ + 409, + 649, + 417, + 657 + ], + "score": 0.76, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 646, + 421, + 660 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 55 + }, + { + "bbox": [ + 301, + 659, + 342, + 669 + ], + "spans": [ + { + "bbox": [ + 301, + 661, + 307, + 669 + ], + "score": 1.0, + "content": "7", + "type": "text" + }, + { + "bbox": [ + 324, + 659, + 342, + 669 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 56 + }, + { + "bbox": [ + 301, + 669, + 465, + 696 + ], + "spans": [ + { + "bbox": [ + 301, + 674, + 307, + 681 + ], + "score": 1.0, + "content": "8", + "type": "text" + }, + { + "bbox": [ + 323, + 669, + 465, + 696 + ], + "score": 0.51, + "content": "\\begin{array} { r } { \\theta ^ { ( t + 1 ) } [ j ] \\theta ^ { ( t ) } [ j ] - \\frac { \\gamma _ { t } } { N } \\sum _ { G \\in \\mathcal { G } } G [ j ] . } \\\\ { \\bar { \\theta } ^ { ( t ) } [ j ] = \\alpha \\bar { \\theta } ^ { ( t - 1 ) } [ j ] + ( 1 - \\alpha ) \\theta ^ { ( t ) } [ j ] . } \\end{array}", + "type": "inline_equation", + "image_path": "862e557fb9bf8b86646596455d0a5a7d5bad24105cdbbc6c579c2f59b82d1861.jpg" + } + ], + "index": 60 + }, + { + "bbox": [ + 301, + 686, + 307, + 693 + ], + "spans": [ + { + "bbox": [ + 301, + 686, + 307, + 693 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ], + "index": 59 + }, + { + "bbox": [ + 301, + 694, + 326, + 704 + ], + "spans": [ + { + "bbox": [ + 301, + 697, + 308, + 704 + ], + "score": 1.0, + "content": "10", + "type": "text" + }, + { + "bbox": [ + 307, + 694, + 326, + 704 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 61 + } + ], + "index": 52.5, + "bbox_fs": [ + 300, + 555, + 482, + 704 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 222, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 224, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 224, + 94 + ], + "score": 1.0, + "content": "3.1 STRAGGLER EFFECTS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 105, + 103, + 504, + 126 + ], + "lines": [ + { + "bbox": [ + 105, + 101, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 101, + 505, + 117 + ], + "score": 1.0, + "content": "The use of backup workers is motivated by the need to mitigate slow stragglers while maximizing", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 115, + 451, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 451, + 127 + ], + "score": 1.0, + "content": "computation. We investigate the effect of stragglers on Sync-Opt model training here.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1.5 + }, + { + "type": "text", + "bbox": [ + 106, + 131, + 506, + 209 + ], + "lines": [ + { + "bbox": [ + 106, + 131, + 505, + 144 + ], + "spans": [ + { + "bbox": [ + 106, + 131, + 197, + 144 + ], + "score": 1.0, + "content": "We ran Sync-Opt with", + "type": "text" + }, + { + "bbox": [ + 198, + 132, + 236, + 142 + ], + "score": 0.89, + "content": "N = 1 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 237, + 131, + 273, + 144 + ], + "score": 1.0, + "content": "workers,", + "type": "text" + }, + { + "bbox": [ + 274, + 132, + 298, + 142 + ], + "score": 0.9, + "content": "b = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 131, + 505, + 144 + ], + "score": 1.0, + "content": "backups, and 19 parameter servers on the Inception", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 142, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 505, + 155 + ], + "score": 1.0, + "content": "model. Using one variable as a proxy, we collected for each iteration both the start time of the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 153, + 506, + 166 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 235, + 166 + ], + "score": 1.0, + "content": "iteration and the time when the", + "type": "text" + }, + { + "bbox": [ + 235, + 154, + 241, + 163 + ], + "score": 0.65, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 153, + 506, + 166 + ], + "score": 1.0, + "content": "th gradient of that variable arrived at the parameter server. These", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 164, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 106, + 164, + 245, + 177 + ], + "score": 1.0, + "content": "times are presented in Figure 3 for", + "type": "text" + }, + { + "bbox": [ + 245, + 164, + 270, + 174 + ], + "score": 0.6, + "content": "k = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 164, + 404, + 177 + ], + "score": 1.0, + "content": ", 50, 90, 97, 98, 99, 100. Note that", + "type": "text" + }, + { + "bbox": [ + 405, + 164, + 424, + 175 + ], + "score": 0.87, + "content": "80 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 164, + 505, + 177 + ], + "score": 1.0, + "content": "of the 98th gradient", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 175, + 505, + 187 + ], + "spans": [ + { + "bbox": [ + 106, + 176, + 241, + 187 + ], + "score": 1.0, + "content": "arrives in under 2s, whereas only", + "type": "text" + }, + { + "bbox": [ + 241, + 175, + 261, + 186 + ], + "score": 0.84, + "content": "30 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 176, + 505, + 187 + ], + "score": 1.0, + "content": "of the final gradient do. Furthermore, the time to collect the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 186, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 106, + 186, + 505, + 199 + ], + "score": 1.0, + "content": "final few gradients grows exponentially, resulting in wasted idle resources and time expended to wait", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 197, + 411, + 209 + ], + "spans": [ + { + "bbox": [ + 105, + 197, + 411, + 209 + ], + "score": 1.0, + "content": "for the slowest gradients. This exponential increase is also seen in Figure 4.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6 + }, + { + "type": "image", + "bbox": [ + 109, + 221, + 298, + 363 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 221, + 298, + 363 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 221, + 298, + 363 + ], + "spans": [ + { + "bbox": [ + 109, + 221, + 298, + 363 + ], + "score": 0.967, + "type": "image", + "image_path": "f142cfb5431917c4256dc4d3a33158daba7d846ffc4487f811dfdda3fff7a939.jpg" + } + ] + } + ], + "index": 15, + "virtual_lines": [ + { + "bbox": [ + 109, + 221, + 298, + 233.9090909090909 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 109, + 233.9090909090909, + 298, + 246.8181818181818 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 109, + 246.8181818181818, + 298, + 259.72727272727275 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 109, + 259.72727272727275, + 298, + 272.6363636363637 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 109, + 272.6363636363637, + 298, + 285.5454545454546 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 109, + 285.5454545454546, + 298, + 298.45454545454555 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 109, + 298.45454545454555, + 298, + 311.3636363636365 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 109, + 311.3636363636365, + 298, + 324.2727272727274 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 109, + 324.2727272727274, + 298, + 337.18181818181836 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 109, + 337.18181818181836, + 298, + 350.0909090909093 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 109, + 350.0909090909093, + 298, + 363.0000000000002 + ], + "spans": [], + "index": 20 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 375, + 302, + 406 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 374, + 303, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 303, + 387 + ], + "score": 1.0, + "content": "Figure 3: CDF of time taken to aggregate gradients", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 384, + 303, + 396 + ], + "spans": [ + { + "bbox": [ + 106, + 384, + 126, + 396 + ], + "score": 1.0, + "content": "from", + "type": "text" + }, + { + "bbox": [ + 127, + 385, + 136, + 394 + ], + "score": 0.75, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 137, + 384, + 303, + 396 + ], + "score": 1.0, + "content": "machines. For clarity, we only show times of", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 395, + 263, + 406 + ], + "spans": [ + { + "bbox": [ + 106, + 395, + 126, + 406 + ], + "score": 0.72, + "content": "\\leq 6 \\mathrm { s }", + "type": "inline_equation" + }, + { + "bbox": [ + 126, + 395, + 263, + 406 + ], + "score": 1.0, + "content": "; the maximum observed time is 310s.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33 + } + ], + "index": 24.0 + }, + { + "type": "image", + "bbox": [ + 312, + 225, + 501, + 363 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 312, + 225, + 501, + 363 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 312, + 225, + 501, + 363 + ], + "spans": [ + { + "bbox": [ + 312, + 225, + 501, + 363 + ], + "score": 0.966, + "type": "image", + "image_path": "1faa87f637ff8939e5bbdb8a66acd6d420b49338648b740f8e467c1caef2ee75.jpg" + } + ] + } + ], + "index": 26, + "virtual_lines": [ + { + "bbox": [ + 312, + 225, + 501, + 237.54545454545453 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 312, + 237.54545454545453, + 501, + 250.09090909090907 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 312, + 250.09090909090907, + 501, + 262.6363636363636 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 312, + 262.6363636363636, + 501, + 275.1818181818182 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 312, + 275.1818181818182, + 501, + 287.72727272727275 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 312, + 287.72727272727275, + 501, + 300.2727272727273 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 312, + 300.2727272727273, + 501, + 312.81818181818187 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 312, + 312.81818181818187, + 501, + 325.36363636363643 + ], + "spans": [], + "index": 28 + }, + { + "bbox": [ + 312, + 325.36363636363643, + 501, + 337.909090909091 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 312, + 337.909090909091, + 501, + 350.45454545454555 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 312, + 350.45454545454555, + 501, + 363.0000000000001 + ], + "spans": [], + "index": 31 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 308, + 375, + 505, + 416 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 308, + 374, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 308, + 374, + 505, + 386 + ], + "score": 1.0, + "content": "Figure 4: Mean and median times, across all itera-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 308, + 385, + 505, + 395 + ], + "spans": [ + { + "bbox": [ + 308, + 385, + 366, + 395 + ], + "score": 1.0, + "content": "tions, to collect", + "type": "text" + }, + { + "bbox": [ + 366, + 385, + 373, + 394 + ], + "score": 0.77, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 373, + 385, + 420, + 395 + ], + "score": 1.0, + "content": "gradients on", + "type": "text" + }, + { + "bbox": [ + 421, + 385, + 457, + 394 + ], + "score": 0.9, + "content": "N = 1 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 385, + 505, + 395 + ], + "score": 1.0, + "content": "workers and", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 308, + 395, + 505, + 406 + ], + "spans": [ + { + "bbox": [ + 308, + 395, + 334, + 405 + ], + "score": 0.89, + "content": "b = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 395, + 505, + 406 + ], + "score": 1.0, + "content": "backups. Most mean times fall between 1.4s", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 308, + 405, + 449, + 416 + ], + "spans": [ + { + "bbox": [ + 308, + 405, + 449, + 416 + ], + "score": 1.0, + "content": "and 1.8s, except of final few gradients.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5 + } + ], + "index": 31.25 + }, + { + "type": "text", + "bbox": [ + 106, + 428, + 505, + 495 + ], + "lines": [ + { + "bbox": [ + 106, + 428, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 106, + 428, + 506, + 442 + ], + "score": 1.0, + "content": "Thus, one might choose to drop slow stragglers to decrease the iteration time. However, using fewer", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 441, + 505, + 452 + ], + "spans": [ + { + "bbox": [ + 106, + 441, + 505, + 452 + ], + "score": 1.0, + "content": "machines implies a smaller effective mini-batch size and thus greater gradient variance, which in turn", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 450, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 104, + 450, + 505, + 464 + ], + "score": 1.0, + "content": "could require more iterations for convergence. We examine this relationship by running Sync-Opt2", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 461, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 126, + 474 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 127, + 462, + 160, + 472 + ], + "score": 0.83, + "content": "N = 5 0", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 461, + 241, + 474 + ], + "score": 1.0, + "content": ", 70, 80, 90, 100 and", + "type": "text" + }, + { + "bbox": [ + 241, + 462, + 265, + 472 + ], + "score": 0.9, + "content": "b = 6", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 461, + 505, + 474 + ], + "score": 1.0, + "content": ", and note the number of iterations required for convergence", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 473, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 428, + 486 + ], + "score": 1.0, + "content": "in Figure 5. Additional details of this training are provided in Appendix A.2. As", + "type": "text" + }, + { + "bbox": [ + 428, + 473, + 438, + 483 + ], + "score": 0.8, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 439, + 473, + 505, + 486 + ], + "score": 1.0, + "content": "is doubled from", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 483, + 450, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 372, + 496 + ], + "score": 1.0, + "content": "50 to 100, the number of iterations to converge nearly halves from", + "type": "text" + }, + { + "bbox": [ + 373, + 484, + 406, + 494 + ], + "score": 0.49, + "content": "1 3 7 . 5 e 3", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 483, + 418, + 496 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 418, + 484, + 446, + 494 + ], + "score": 0.7, + "content": "7 6 . 2 e 3", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 483, + 450, + 496 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 41.5 + }, + { + "type": "image", + "bbox": [ + 109, + 510, + 298, + 648 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 510, + 298, + 648 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 109, + 510, + 298, + 648 + ], + "spans": [ + { + "bbox": [ + 109, + 510, + 298, + 648 + ], + "score": 0.968, + "type": "image", + "image_path": "808b4545e00ca62fea4a8ae6f8ace30f28b4dffb9d1dabc8f1fdf079679549b0.jpg" + } + ] + } + ], + "index": 50, + "virtual_lines": [ + { + "bbox": [ + 109, + 510, + 298, + 522.5454545454545 + ], + "spans": [], + "index": 45 + }, + { + "bbox": [ + 109, + 522.5454545454545, + 298, + 535.090909090909 + ], + "spans": [], + "index": 46 + }, + { + "bbox": [ + 109, + 535.090909090909, + 298, + 547.6363636363635 + ], + "spans": [], + "index": 47 + }, + { + "bbox": [ + 109, + 547.6363636363635, + 298, + 560.181818181818 + ], + "spans": [], + "index": 48 + }, + { + "bbox": [ + 109, + 560.181818181818, + 298, + 572.7272727272725 + ], + "spans": [], + "index": 49 + }, + { + "bbox": [ + 109, + 572.7272727272725, + 298, + 585.272727272727 + ], + "spans": [], + "index": 50 + }, + { + "bbox": [ + 109, + 585.272727272727, + 298, + 597.8181818181815 + ], + "spans": [], + "index": 51 + }, + { + "bbox": [ + 109, + 597.8181818181815, + 298, + 610.363636363636 + ], + "spans": [], + "index": 52 + }, + { + "bbox": [ + 109, + 610.363636363636, + 298, + 622.9090909090905 + ], + "spans": [], + "index": 53 + }, + { + "bbox": [ + 109, + 622.9090909090905, + 298, + 635.454545454545 + ], + "spans": [], + "index": 54 + }, + { + "bbox": [ + 109, + 635.454545454545, + 298, + 647.9999999999995 + ], + "spans": [], + "index": 55 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 660, + 302, + 681 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 105, + 658, + 303, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 303, + 672 + ], + "score": 1.0, + "content": "Figure 5: Number of iterations to converge when ag-", + "type": "text" + } + ], + "index": 67 + }, + { + "bbox": [ + 106, + 670, + 243, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 670, + 194, + 680 + ], + "score": 1.0, + "content": "gregating gradient from", + "type": "text" + }, + { + "bbox": [ + 194, + 670, + 203, + 679 + ], + "score": 0.77, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 204, + 670, + 243, + 680 + ], + "score": 1.0, + "content": "machines.", + "type": "text" + } + ], + "index": 68 + } + ], + "index": 67.5 + } + ], + "index": 58.75 + }, + { + "type": "image", + "bbox": [ + 312, + 508, + 500, + 648 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 312, + 508, + 500, + 648 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 312, + 508, + 500, + 648 + ], + "spans": [ + { + "bbox": [ + 312, + 508, + 500, + 648 + ], + "score": 0.969, + "type": "image", + "image_path": "9b0b18171010653451f924f726f76139bfecb911a4efdc1c7e6e56ca49a25b7b.jpg" + } + ] + } + ], + "index": 61, + "virtual_lines": [ + { + "bbox": [ + 312, + 508, + 500, + 520.7272727272727 + ], + "spans": [], + "index": 56 + }, + { + "bbox": [ + 312, + 520.7272727272727, + 500, + 533.4545454545455 + ], + "spans": [], + "index": 57 + }, + { + "bbox": [ + 312, + 533.4545454545455, + 500, + 546.1818181818182 + ], + "spans": [], + "index": 58 + }, + { + "bbox": [ + 312, + 546.1818181818182, + 500, + 558.909090909091 + ], + "spans": [], + "index": 59 + }, + { + "bbox": [ + 312, + 558.909090909091, + 500, + 571.6363636363637 + ], + "spans": [], + "index": 60 + }, + { + "bbox": [ + 312, + 571.6363636363637, + 500, + 584.3636363636365 + ], + "spans": [], + "index": 61 + }, + { + "bbox": [ + 312, + 584.3636363636365, + 500, + 597.0909090909092 + ], + "spans": [], + "index": 62 + }, + { + "bbox": [ + 312, + 597.0909090909092, + 500, + 609.818181818182 + ], + "spans": [], + "index": 63 + }, + { + "bbox": [ + 312, + 609.818181818182, + 500, + 622.5454545454547 + ], + "spans": [], + "index": 64 + }, + { + "bbox": [ + 312, + 622.5454545454547, + 500, + 635.2727272727275 + ], + "spans": [], + "index": 65 + }, + { + "bbox": [ + 312, + 635.2727272727275, + 500, + 648.0000000000002 + ], + "spans": [], + "index": 66 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 308, + 660, + 505, + 700 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 307, + 659, + 505, + 671 + ], + "spans": [ + { + "bbox": [ + 307, + 659, + 505, + 671 + ], + "score": 1.0, + "content": "Figure 6: Estimated time to converge when aggregat-", + "type": "text" + } + ], + "index": 69 + }, + { + "bbox": [ + 307, + 670, + 504, + 680 + ], + "spans": [ + { + "bbox": [ + 307, + 670, + 380, + 680 + ], + "score": 1.0, + "content": "ing gradients from", + "type": "text" + }, + { + "bbox": [ + 380, + 670, + 389, + 679 + ], + "score": 0.76, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 670, + 448, + 680 + ], + "score": 1.0, + "content": "machines on a", + "type": "text" + }, + { + "bbox": [ + 448, + 670, + 504, + 680 + ], + "score": 0.9, + "content": "N + b = \\bar { 1 } 0 0", + "type": "inline_equation" + } + ], + "index": 70 + }, + { + "bbox": [ + 308, + 680, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 308, + 680, + 505, + 690 + ], + "score": 1.0, + "content": "machine configuration. Convergence is fastest when", + "type": "text" + } + ], + "index": 71 + }, + { + "bbox": [ + 308, + 690, + 403, + 701 + ], + "spans": [ + { + "bbox": [ + 308, + 690, + 343, + 701 + ], + "score": 1.0, + "content": "choosing", + "type": "text" + }, + { + "bbox": [ + 343, + 690, + 374, + 699 + ], + "score": 0.84, + "content": "N = 9 6", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 690, + 377, + 701 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 378, + 690, + 399, + 699 + ], + "score": 0.84, + "content": "b = 4", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 690, + 403, + 701 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 72 + } + ], + "index": 70.5 + } + ], + "index": 65.75 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 105, + 712, + 506, + 732 + ], + "lines": [ + { + "bbox": [ + 118, + 709, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 118, + 709, + 506, + 724 + ], + "score": 1.0, + "content": "2 Since we are interested in the gradient quality and convergence behavior but not running time in this", + "type": "text" + } + ] + }, + { + "bbox": [ + 105, + 721, + 467, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 467, + 732 + ], + "score": 1.0, + "content": "experiment, the backups serve only to reduce our data collection time but do not affect our analysis.", + "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": "5", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 222, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 224, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 224, + 94 + ], + "score": 1.0, + "content": "3.1 STRAGGLER EFFECTS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 105, + 103, + 504, + 126 + ], + "lines": [ + { + "bbox": [ + 105, + 101, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 101, + 505, + 117 + ], + "score": 1.0, + "content": "The use of backup workers is motivated by the need to mitigate slow stragglers while maximizing", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 115, + 451, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 451, + 127 + ], + "score": 1.0, + "content": "computation. We investigate the effect of stragglers on Sync-Opt model training here.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1.5, + "bbox_fs": [ + 105, + 101, + 505, + 127 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 131, + 506, + 209 + ], + "lines": [ + { + "bbox": [ + 106, + 131, + 505, + 144 + ], + "spans": [ + { + "bbox": [ + 106, + 131, + 197, + 144 + ], + "score": 1.0, + "content": "We ran Sync-Opt with", + "type": "text" + }, + { + "bbox": [ + 198, + 132, + 236, + 142 + ], + "score": 0.89, + "content": "N = 1 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 237, + 131, + 273, + 144 + ], + "score": 1.0, + "content": "workers,", + "type": "text" + }, + { + "bbox": [ + 274, + 132, + 298, + 142 + ], + "score": 0.9, + "content": "b = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 131, + 505, + 144 + ], + "score": 1.0, + "content": "backups, and 19 parameter servers on the Inception", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 142, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 505, + 155 + ], + "score": 1.0, + "content": "model. Using one variable as a proxy, we collected for each iteration both the start time of the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 153, + 506, + 166 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 235, + 166 + ], + "score": 1.0, + "content": "iteration and the time when the", + "type": "text" + }, + { + "bbox": [ + 235, + 154, + 241, + 163 + ], + "score": 0.65, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 153, + 506, + 166 + ], + "score": 1.0, + "content": "th gradient of that variable arrived at the parameter server. These", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 164, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 106, + 164, + 245, + 177 + ], + "score": 1.0, + "content": "times are presented in Figure 3 for", + "type": "text" + }, + { + "bbox": [ + 245, + 164, + 270, + 174 + ], + "score": 0.6, + "content": "k = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 164, + 404, + 177 + ], + "score": 1.0, + "content": ", 50, 90, 97, 98, 99, 100. Note that", + "type": "text" + }, + { + "bbox": [ + 405, + 164, + 424, + 175 + ], + "score": 0.87, + "content": "80 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 164, + 505, + 177 + ], + "score": 1.0, + "content": "of the 98th gradient", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 175, + 505, + 187 + ], + "spans": [ + { + "bbox": [ + 106, + 176, + 241, + 187 + ], + "score": 1.0, + "content": "arrives in under 2s, whereas only", + "type": "text" + }, + { + "bbox": [ + 241, + 175, + 261, + 186 + ], + "score": 0.84, + "content": "30 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 176, + 505, + 187 + ], + "score": 1.0, + "content": "of the final gradient do. Furthermore, the time to collect the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 186, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 106, + 186, + 505, + 199 + ], + "score": 1.0, + "content": "final few gradients grows exponentially, resulting in wasted idle resources and time expended to wait", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 197, + 411, + 209 + ], + "spans": [ + { + "bbox": [ + 105, + 197, + 411, + 209 + ], + "score": 1.0, + "content": "for the slowest gradients. This exponential increase is also seen in Figure 4.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6, + "bbox_fs": [ + 105, + 131, + 506, + 209 + ] + }, + { + "type": "image", + "bbox": [ + 109, + 221, + 298, + 363 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 221, + 298, + 363 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 221, + 298, + 363 + ], + "spans": [ + { + "bbox": [ + 109, + 221, + 298, + 363 + ], + "score": 0.967, + "type": "image", + "image_path": "f142cfb5431917c4256dc4d3a33158daba7d846ffc4487f811dfdda3fff7a939.jpg" + } + ] + } + ], + "index": 15, + "virtual_lines": [ + { + "bbox": [ + 109, + 221, + 298, + 233.9090909090909 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 109, + 233.9090909090909, + 298, + 246.8181818181818 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 109, + 246.8181818181818, + 298, + 259.72727272727275 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 109, + 259.72727272727275, + 298, + 272.6363636363637 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 109, + 272.6363636363637, + 298, + 285.5454545454546 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 109, + 285.5454545454546, + 298, + 298.45454545454555 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 109, + 298.45454545454555, + 298, + 311.3636363636365 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 109, + 311.3636363636365, + 298, + 324.2727272727274 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 109, + 324.2727272727274, + 298, + 337.18181818181836 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 109, + 337.18181818181836, + 298, + 350.0909090909093 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 109, + 350.0909090909093, + 298, + 363.0000000000002 + ], + "spans": [], + "index": 20 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 375, + 302, + 406 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 374, + 303, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 303, + 387 + ], + "score": 1.0, + "content": "Figure 3: CDF of time taken to aggregate gradients", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 384, + 303, + 396 + ], + "spans": [ + { + "bbox": [ + 106, + 384, + 126, + 396 + ], + "score": 1.0, + "content": "from", + "type": "text" + }, + { + "bbox": [ + 127, + 385, + 136, + 394 + ], + "score": 0.75, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 137, + 384, + 303, + 396 + ], + "score": 1.0, + "content": "machines. For clarity, we only show times of", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 395, + 263, + 406 + ], + "spans": [ + { + "bbox": [ + 106, + 395, + 126, + 406 + ], + "score": 0.72, + "content": "\\leq 6 \\mathrm { s }", + "type": "inline_equation" + }, + { + "bbox": [ + 126, + 395, + 263, + 406 + ], + "score": 1.0, + "content": "; the maximum observed time is 310s.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33 + } + ], + "index": 24.0 + }, + { + "type": "image", + "bbox": [ + 312, + 225, + 501, + 363 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 312, + 225, + 501, + 363 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 312, + 225, + 501, + 363 + ], + "spans": [ + { + "bbox": [ + 312, + 225, + 501, + 363 + ], + "score": 0.966, + "type": "image", + "image_path": "1faa87f637ff8939e5bbdb8a66acd6d420b49338648b740f8e467c1caef2ee75.jpg" + } + ] + } + ], + "index": 26, + "virtual_lines": [ + { + "bbox": [ + 312, + 225, + 501, + 237.54545454545453 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 312, + 237.54545454545453, + 501, + 250.09090909090907 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 312, + 250.09090909090907, + 501, + 262.6363636363636 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 312, + 262.6363636363636, + 501, + 275.1818181818182 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 312, + 275.1818181818182, + 501, + 287.72727272727275 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 312, + 287.72727272727275, + 501, + 300.2727272727273 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 312, + 300.2727272727273, + 501, + 312.81818181818187 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 312, + 312.81818181818187, + 501, + 325.36363636363643 + ], + "spans": [], + "index": 28 + }, + { + "bbox": [ + 312, + 325.36363636363643, + 501, + 337.909090909091 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 312, + 337.909090909091, + 501, + 350.45454545454555 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 312, + 350.45454545454555, + 501, + 363.0000000000001 + ], + "spans": [], + "index": 31 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 308, + 375, + 505, + 416 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 308, + 374, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 308, + 374, + 505, + 386 + ], + "score": 1.0, + "content": "Figure 4: Mean and median times, across all itera-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 308, + 385, + 505, + 395 + ], + "spans": [ + { + "bbox": [ + 308, + 385, + 366, + 395 + ], + "score": 1.0, + "content": "tions, to collect", + "type": "text" + }, + { + "bbox": [ + 366, + 385, + 373, + 394 + ], + "score": 0.77, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 373, + 385, + 420, + 395 + ], + "score": 1.0, + "content": "gradients on", + "type": "text" + }, + { + "bbox": [ + 421, + 385, + 457, + 394 + ], + "score": 0.9, + "content": "N = 1 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 385, + 505, + 395 + ], + "score": 1.0, + "content": "workers and", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 308, + 395, + 505, + 406 + ], + "spans": [ + { + "bbox": [ + 308, + 395, + 334, + 405 + ], + "score": 0.89, + "content": "b = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 395, + 505, + 406 + ], + "score": 1.0, + "content": "backups. Most mean times fall between 1.4s", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 308, + 405, + 449, + 416 + ], + "spans": [ + { + "bbox": [ + 308, + 405, + 449, + 416 + ], + "score": 1.0, + "content": "and 1.8s, except of final few gradients.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5 + } + ], + "index": 31.25 + }, + { + "type": "text", + "bbox": [ + 106, + 428, + 505, + 495 + ], + "lines": [ + { + "bbox": [ + 106, + 428, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 106, + 428, + 506, + 442 + ], + "score": 1.0, + "content": "Thus, one might choose to drop slow stragglers to decrease the iteration time. However, using fewer", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 441, + 505, + 452 + ], + "spans": [ + { + "bbox": [ + 106, + 441, + 505, + 452 + ], + "score": 1.0, + "content": "machines implies a smaller effective mini-batch size and thus greater gradient variance, which in turn", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 450, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 104, + 450, + 505, + 464 + ], + "score": 1.0, + "content": "could require more iterations for convergence. We examine this relationship by running Sync-Opt2", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 461, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 126, + 474 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 127, + 462, + 160, + 472 + ], + "score": 0.83, + "content": "N = 5 0", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 461, + 241, + 474 + ], + "score": 1.0, + "content": ", 70, 80, 90, 100 and", + "type": "text" + }, + { + "bbox": [ + 241, + 462, + 265, + 472 + ], + "score": 0.9, + "content": "b = 6", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 461, + 505, + 474 + ], + "score": 1.0, + "content": ", and note the number of iterations required for convergence", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 473, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 428, + 486 + ], + "score": 1.0, + "content": "in Figure 5. Additional details of this training are provided in Appendix A.2. As", + "type": "text" + }, + { + "bbox": [ + 428, + 473, + 438, + 483 + ], + "score": 0.8, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 439, + 473, + 505, + 486 + ], + "score": 1.0, + "content": "is doubled from", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 483, + 450, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 372, + 496 + ], + "score": 1.0, + "content": "50 to 100, the number of iterations to converge nearly halves from", + "type": "text" + }, + { + "bbox": [ + 373, + 484, + 406, + 494 + ], + "score": 0.49, + "content": "1 3 7 . 5 e 3", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 483, + 418, + 496 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 418, + 484, + 446, + 494 + ], + "score": 0.7, + "content": "7 6 . 2 e 3", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 483, + 450, + 496 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 41.5, + "bbox_fs": [ + 104, + 428, + 506, + 496 + ] + }, + { + "type": "image", + "bbox": [ + 109, + 510, + 298, + 648 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 510, + 298, + 648 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 109, + 510, + 298, + 648 + ], + "spans": [ + { + "bbox": [ + 109, + 510, + 298, + 648 + ], + "score": 0.968, + "type": "image", + "image_path": "808b4545e00ca62fea4a8ae6f8ace30f28b4dffb9d1dabc8f1fdf079679549b0.jpg" + } + ] + } + ], + "index": 50, + "virtual_lines": [ + { + "bbox": [ + 109, + 510, + 298, + 522.5454545454545 + ], + "spans": [], + "index": 45 + }, + { + "bbox": [ + 109, + 522.5454545454545, + 298, + 535.090909090909 + ], + "spans": [], + "index": 46 + }, + { + "bbox": [ + 109, + 535.090909090909, + 298, + 547.6363636363635 + ], + "spans": [], + "index": 47 + }, + { + "bbox": [ + 109, + 547.6363636363635, + 298, + 560.181818181818 + ], + "spans": [], + "index": 48 + }, + { + "bbox": [ + 109, + 560.181818181818, + 298, + 572.7272727272725 + ], + "spans": [], + "index": 49 + }, + { + "bbox": [ + 109, + 572.7272727272725, + 298, + 585.272727272727 + ], + "spans": [], + "index": 50 + }, + { + "bbox": [ + 109, + 585.272727272727, + 298, + 597.8181818181815 + ], + "spans": [], + "index": 51 + }, + { + "bbox": [ + 109, + 597.8181818181815, + 298, + 610.363636363636 + ], + "spans": [], + "index": 52 + }, + { + "bbox": [ + 109, + 610.363636363636, + 298, + 622.9090909090905 + ], + "spans": [], + "index": 53 + }, + { + "bbox": [ + 109, + 622.9090909090905, + 298, + 635.454545454545 + ], + "spans": [], + "index": 54 + }, + { + "bbox": [ + 109, + 635.454545454545, + 298, + 647.9999999999995 + ], + "spans": [], + "index": 55 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 660, + 302, + 681 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 105, + 658, + 303, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 303, + 672 + ], + "score": 1.0, + "content": "Figure 5: Number of iterations to converge when ag-", + "type": "text" + } + ], + "index": 67 + }, + { + "bbox": [ + 106, + 670, + 243, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 670, + 194, + 680 + ], + "score": 1.0, + "content": "gregating gradient from", + "type": "text" + }, + { + "bbox": [ + 194, + 670, + 203, + 679 + ], + "score": 0.77, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 204, + 670, + 243, + 680 + ], + "score": 1.0, + "content": "machines.", + "type": "text" + } + ], + "index": 68 + } + ], + "index": 67.5 + } + ], + "index": 58.75 + }, + { + "type": "image", + "bbox": [ + 312, + 508, + 500, + 648 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 312, + 508, + 500, + 648 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 312, + 508, + 500, + 648 + ], + "spans": [ + { + "bbox": [ + 312, + 508, + 500, + 648 + ], + "score": 0.969, + "type": "image", + "image_path": "9b0b18171010653451f924f726f76139bfecb911a4efdc1c7e6e56ca49a25b7b.jpg" + } + ] + } + ], + "index": 61, + "virtual_lines": [ + { + "bbox": [ + 312, + 508, + 500, + 520.7272727272727 + ], + "spans": [], + "index": 56 + }, + { + "bbox": [ + 312, + 520.7272727272727, + 500, + 533.4545454545455 + ], + "spans": [], + "index": 57 + }, + { + "bbox": [ + 312, + 533.4545454545455, + 500, + 546.1818181818182 + ], + "spans": [], + "index": 58 + }, + { + "bbox": [ + 312, + 546.1818181818182, + 500, + 558.909090909091 + ], + "spans": [], + "index": 59 + }, + { + "bbox": [ + 312, + 558.909090909091, + 500, + 571.6363636363637 + ], + "spans": [], + "index": 60 + }, + { + "bbox": [ + 312, + 571.6363636363637, + 500, + 584.3636363636365 + ], + "spans": [], + "index": 61 + }, + { + "bbox": [ + 312, + 584.3636363636365, + 500, + 597.0909090909092 + ], + "spans": [], + "index": 62 + }, + { + "bbox": [ + 312, + 597.0909090909092, + 500, + 609.818181818182 + ], + "spans": [], + "index": 63 + }, + { + "bbox": [ + 312, + 609.818181818182, + 500, + 622.5454545454547 + ], + "spans": [], + "index": 64 + }, + { + "bbox": [ + 312, + 622.5454545454547, + 500, + 635.2727272727275 + ], + "spans": [], + "index": 65 + }, + { + "bbox": [ + 312, + 635.2727272727275, + 500, + 648.0000000000002 + ], + "spans": [], + "index": 66 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 308, + 660, + 505, + 700 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 307, + 659, + 505, + 671 + ], + "spans": [ + { + "bbox": [ + 307, + 659, + 505, + 671 + ], + "score": 1.0, + "content": "Figure 6: Estimated time to converge when aggregat-", + "type": "text" + } + ], + "index": 69 + }, + { + "bbox": [ + 307, + 670, + 504, + 680 + ], + "spans": [ + { + "bbox": [ + 307, + 670, + 380, + 680 + ], + "score": 1.0, + "content": "ing gradients from", + "type": "text" + }, + { + "bbox": [ + 380, + 670, + 389, + 679 + ], + "score": 0.76, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 670, + 448, + 680 + ], + "score": 1.0, + "content": "machines on a", + "type": "text" + }, + { + "bbox": [ + 448, + 670, + 504, + 680 + ], + "score": 0.9, + "content": "N + b = \\bar { 1 } 0 0", + "type": "inline_equation" + } + ], + "index": 70 + }, + { + "bbox": [ + 308, + 680, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 308, + 680, + 505, + 690 + ], + "score": 1.0, + "content": "machine configuration. Convergence is fastest when", + "type": "text" + } + ], + "index": 71 + }, + { + "bbox": [ + 308, + 690, + 403, + 701 + ], + "spans": [ + { + "bbox": [ + 308, + 690, + 343, + 701 + ], + "score": 1.0, + "content": "choosing", + "type": "text" + }, + { + "bbox": [ + 343, + 690, + 374, + 699 + ], + "score": 0.84, + "content": "N = 9 6", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 690, + 377, + 701 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 378, + 690, + 399, + 699 + ], + "score": 0.84, + "content": "b = 4", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 690, + 403, + 701 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 72 + } + ], + "index": 70.5 + } + ], + "index": 65.75 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 171 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "Hence, there is a trade-off between dropping more stragglers to reduce iteration time, and waiting", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "for more gradients to improve the gradient quality. Consider a hypothetical setting where we have", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 107, + 104, + 506, + 117 + ], + "spans": [ + { + "bbox": [ + 107, + 105, + 167, + 115 + ], + "score": 0.91, + "content": "N + b = 1 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 104, + 415, + 117 + ], + "score": 1.0, + "content": "machines, and we wish to choose the best configuration of", + "type": "text" + }, + { + "bbox": [ + 415, + 105, + 426, + 114 + ], + "score": 0.82, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 104, + 445, + 117 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 446, + 105, + 452, + 114 + ], + "score": 0.69, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 104, + 506, + 117 + ], + "score": 1.0, + "content": "to minimize", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "score": 1.0, + "content": "running time to convergence3. For each configuration, we can estimate the iterations required from", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 285, + 140 + ], + "score": 1.0, + "content": "Figure 5 (linearly interpolating for values of", + "type": "text" + }, + { + "bbox": [ + 285, + 127, + 295, + 136 + ], + "score": 0.81, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 296, + 126, + 505, + 140 + ], + "score": 1.0, + "content": "for which we did not collect data). We can multiply", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 505, + 150 + ], + "score": 1.0, + "content": "this with the mean iteration times (Figure 4) to obtain the running time required to converge for each", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 147, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 147, + 147, + 162 + ], + "score": 1.0, + "content": "setting of", + "type": "text" + }, + { + "bbox": [ + 147, + 149, + 158, + 158 + ], + "score": 0.8, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 158, + 147, + 176, + 162 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 176, + 149, + 182, + 158 + ], + "score": 0.65, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 147, + 397, + 162 + ], + "score": 1.0, + "content": ". These results are shown in Figure 6, indicating that", + "type": "text" + }, + { + "bbox": [ + 397, + 149, + 432, + 159 + ], + "score": 0.85, + "content": "N = 9 6", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 147, + 436, + 162 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 436, + 149, + 462, + 159 + ], + "score": 0.82, + "content": "b = 4", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 147, + 505, + 162 + ], + "score": 1.0, + "content": "converges", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 501, + 172 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 501, + 172 + ], + "score": 1.0, + "content": "fastest. Therefore, this motivates our choice to use a few backup workers for mitigating stragglers.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 3.5 + }, + { + "type": "title", + "bbox": [ + 108, + 187, + 200, + 199 + ], + "lines": [ + { + "bbox": [ + 105, + 186, + 201, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 201, + 201 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 212, + 505, + 245 + ], + "lines": [ + { + "bbox": [ + 105, + 211, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 211, + 505, + 225 + ], + "score": 1.0, + "content": "In this section, we present our empirical comparisons of synchronous and asynchronous distributed", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 222, + 506, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 222, + 506, + 236 + ], + "score": 1.0, + "content": "stochastic optimization algorithms as applied to models such as Inception and PixelCNN. All exper-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 234, + 403, + 246 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 403, + 246 + ], + "score": 1.0, + "content": "iments in this paper are using the TensorFlow system (Abadi et al., 2015).", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + }, + { + "type": "title", + "bbox": [ + 107, + 258, + 434, + 270 + ], + "lines": [ + { + "bbox": [ + 105, + 258, + 436, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 258, + 436, + 271 + ], + "score": 1.0, + "content": "4.1 METRICS OF COMPARISON: FASTER CONVERGENCE, BETTER OPTIMUM", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 279, + 505, + 324 + ], + "lines": [ + { + "bbox": [ + 106, + 279, + 505, + 291 + ], + "spans": [ + { + "bbox": [ + 106, + 279, + 505, + 291 + ], + "score": 1.0, + "content": "We are interested in two metrics of comparison for our empirical validation: (1) test error or ac-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 290, + 505, + 303 + ], + "spans": [ + { + "bbox": [ + 106, + 290, + 505, + 303 + ], + "score": 1.0, + "content": "curacy, and (2) speed of convergence3. We point out that for non-convex deep learning models,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 300, + 506, + 315 + ], + "spans": [ + { + "bbox": [ + 105, + 300, + 506, + 315 + ], + "score": 1.0, + "content": "it is possible to converge faster to a poorer local optimum. Here we show a simple example with", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 312, + 266, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 312, + 266, + 325 + ], + "score": 1.0, + "content": "Inception using different learning rates.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 14.5 + }, + { + "type": "table", + "bbox": [ + 106, + 354, + 246, + 437 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 354, + 246, + 437 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 354, + 246, + 437 + ], + "spans": [ + { + "bbox": [ + 106, + 354, + 246, + 437 + ], + "score": 0.955, + "html": "
Initial rate 20Test precision at convergenceEpochs to converge
1.125 2.2577.29% 77.75%52628 65811
4.5
9.078.15%76209
78.17%77235
", + "type": "table", + "image_path": "a5721568a454d9eb4d6b58098695145714eed7c25b8fae79b2905aa7d541c982.jpg" + } + ] + } + ], + "index": 18.0, + "virtual_lines": [ + { + "bbox": [ + 106, + 354, + 246, + 395.5 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 106, + 395.5, + 246, + 437.0 + ], + "spans": [], + "index": 19 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 106, + 445, + 243, + 506 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 445, + 244, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 445, + 244, + 457 + ], + "score": 1.0, + "content": "Table 2: Test accuracies at con-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 456, + 244, + 466 + ], + "spans": [ + { + "bbox": [ + 106, + 456, + 244, + 466 + ], + "score": 1.0, + "content": "vergence and number of epochs to", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 465, + 244, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 244, + 478 + ], + "score": 1.0, + "content": "converge for different initial learning", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 476, + 243, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 476, + 127, + 487 + ], + "score": 1.0, + "content": "rates", + "type": "text" + }, + { + "bbox": [ + 127, + 478, + 137, + 486 + ], + "score": 0.82, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 137, + 476, + 243, + 487 + ], + "score": 1.0, + "content": ". Low initial learning rates", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 486, + 244, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 244, + 497 + ], + "score": 1.0, + "content": "result in faster convergence to poorer", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 496, + 163, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 163, + 507 + ], + "score": 1.0, + "content": "local optimum.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24.5 + } + ], + "index": 21.25 + }, + { + "type": "image", + "bbox": [ + 250, + 335, + 499, + 446 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 250, + 335, + 499, + 446 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 250, + 335, + 499, + 446 + ], + "spans": [ + { + "bbox": [ + 250, + 335, + 499, + 446 + ], + "score": 0.97, + "type": "image", + "image_path": "cf7dd8a2918112ad1401df8582e7cb61ac45e2309e2c05a587c225cae4d880a5.jpg" + } + ] + } + ], + "index": 20, + "virtual_lines": [ + { + "bbox": [ + 250, + 335, + 499, + 372.0 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 250, + 372.0, + 499, + 409.0 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 250, + 409.0, + 499, + 446.0 + ], + "spans": [], + "index": 21 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 249, + 456, + 504, + 506 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 248, + 455, + 505, + 467 + ], + "spans": [ + { + "bbox": [ + 248, + 455, + 483, + 467 + ], + "score": 1.0, + "content": "Figure 7: Convergence of Sync-Opt on Inception model using", + "type": "text" + }, + { + "bbox": [ + 483, + 456, + 505, + 466 + ], + "score": 0.83, + "content": "N =", + "type": "inline_equation" + } + ], + "index": 28 + }, + { + "bbox": [ + 248, + 464, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 248, + 464, + 311, + 478 + ], + "score": 1.0, + "content": "100 workers and", + "type": "text" + }, + { + "bbox": [ + 312, + 466, + 334, + 475 + ], + "score": 0.9, + "content": "b = 6", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 464, + 491, + 478 + ], + "score": 1.0, + "content": "backups, with varying initial learning rates", + "type": "text" + }, + { + "bbox": [ + 491, + 468, + 501, + 477 + ], + "score": 0.79, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 464, + 505, + 478 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 248, + 475, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 248, + 475, + 311, + 487 + ], + "score": 1.0, + "content": "To reach a lower", + "type": "text" + }, + { + "bbox": [ + 311, + 478, + 317, + 485 + ], + "score": 0.6, + "content": "\\epsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 475, + 392, + 487 + ], + "score": 1.0, + "content": "test precision, small", + "type": "text" + }, + { + "bbox": [ + 392, + 477, + 402, + 486 + ], + "score": 0.84, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 475, + 505, + 487 + ], + "score": 1.0, + "content": "’s require fewer epochs than", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 248, + 486, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 248, + 486, + 268, + 497 + ], + "score": 1.0, + "content": "large", + "type": "text" + }, + { + "bbox": [ + 269, + 487, + 279, + 496 + ], + "score": 0.83, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 486, + 347, + 497 + ], + "score": 1.0, + "content": "’s. However, small", + "type": "text" + }, + { + "bbox": [ + 347, + 487, + 357, + 496 + ], + "score": 0.85, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 358, + 486, + 451, + 497 + ], + "score": 1.0, + "content": "’s either fail to attain high", + "type": "text" + }, + { + "bbox": [ + 451, + 488, + 457, + 495 + ], + "score": 0.68, + "content": "\\epsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 486, + 505, + 497 + ], + "score": 1.0, + "content": "precision, or", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 249, + 496, + 376, + 507 + ], + "spans": [ + { + "bbox": [ + 249, + 496, + 357, + 507 + ], + "score": 1.0, + "content": "take more epochs than higher", + "type": "text" + }, + { + "bbox": [ + 357, + 497, + 367, + 506 + ], + "score": 0.82, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 496, + 376, + 507 + ], + "score": 1.0, + "content": "’s.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30 + } + ], + "index": 25.0 + }, + { + "type": "text", + "bbox": [ + 107, + 518, + 505, + 585 + ], + "lines": [ + { + "bbox": [ + 105, + 516, + 504, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 256, + 533 + ], + "score": 1.0, + "content": "We ran Sync-Opt on Inception with", + "type": "text" + }, + { + "bbox": [ + 257, + 519, + 299, + 529 + ], + "score": 0.9, + "content": "N = 1 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 516, + 319, + 533 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 319, + 519, + 347, + 529 + ], + "score": 0.9, + "content": "b = 6", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 516, + 492, + 533 + ], + "score": 1.0, + "content": ", but varied the initial learning rate", + "type": "text" + }, + { + "bbox": [ + 493, + 521, + 504, + 530 + ], + "score": 0.82, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 529, + 506, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 506, + 542 + ], + "score": 1.0, + "content": "between 1.125 and 9.0. (Learning rates are exponentially decreased with iterations.) Table 2 shows", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 540, + 505, + 553 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 156, + 553 + ], + "score": 1.0, + "content": "that smaller", + "type": "text" + }, + { + "bbox": [ + 156, + 542, + 168, + 552 + ], + "score": 0.85, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 540, + 505, + 553 + ], + "score": 1.0, + "content": "converge faster, but to poorer test precisions. Focusing on speed on an early phase", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 551, + 505, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 505, + 564 + ], + "score": 1.0, + "content": "of training could lead to misleading conclusions if we fail to account for eventual convergence.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 562, + 505, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 562, + 273, + 575 + ], + "score": 1.0, + "content": "For example, Figure 3b shows that using", + "type": "text" + }, + { + "bbox": [ + 274, + 563, + 323, + 574 + ], + "score": 0.9, + "content": "\\gamma _ { 0 } = 1 . 1 2 5", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 562, + 357, + 575 + ], + "score": 1.0, + "content": "reaches", + "type": "text" + }, + { + "bbox": [ + 357, + 562, + 396, + 573 + ], + "score": 0.91, + "content": "\\epsilon = 7 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 562, + 437, + 575 + ], + "score": 1.0, + "content": "precision", + "type": "text" + }, + { + "bbox": [ + 437, + 563, + 459, + 573 + ], + "score": 0.86, + "content": "1 . 5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 459, + 562, + 505, + 575 + ], + "score": 1.0, + "content": "faster than", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 573, + 412, + 586 + ], + "spans": [ + { + "bbox": [ + 106, + 574, + 143, + 585 + ], + "score": 0.91, + "content": "\\gamma _ { 0 } = 4 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 573, + 214, + 586 + ], + "score": 1.0, + "content": ", but is slower for", + "type": "text" + }, + { + "bbox": [ + 214, + 573, + 264, + 585 + ], + "score": 0.91, + "content": "\\epsilon = 7 7 . 7 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 573, + 412, + 586 + ], + "score": 1.0, + "content": ", and fails to reach higher precisions.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 35.5 + }, + { + "type": "title", + "bbox": [ + 107, + 598, + 179, + 609 + ], + "lines": [ + { + "bbox": [ + 105, + 598, + 180, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 180, + 611 + ], + "score": 1.0, + "content": "4.2 INCEPTION", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 107, + 618, + 505, + 685 + ], + "lines": [ + { + "bbox": [ + 106, + 619, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 106, + 619, + 505, + 632 + ], + "score": 1.0, + "content": "We conducted experiments on the Inception model (Szegedy et al., 2016) trained on ImageNet Chal-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 629, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 505, + 643 + ], + "score": 1.0, + "content": "lenge dataset (Russakovsky et al., 2015), where the task is to classify images out of 1000 categories.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 641, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 271, + 654 + ], + "score": 1.0, + "content": "We used several configurations, varying", + "type": "text" + }, + { + "bbox": [ + 271, + 641, + 299, + 651 + ], + "score": 0.9, + "content": "N + b", + "type": "inline_equation" + }, + { + "bbox": [ + 299, + 641, + 505, + 654 + ], + "score": 1.0, + "content": "from 53 to 212 workers. Additional details of the", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 651, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 505, + 664 + ], + "score": 1.0, + "content": "training are provided in Appendix A.3. An epoch is a synchronous iteration for Sync-Opt, or a full", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 662, + 506, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 662, + 137, + 676 + ], + "score": 1.0, + "content": "pass of", + "type": "text" + }, + { + "bbox": [ + 137, + 663, + 148, + 673 + ], + "score": 0.78, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 148, + 662, + 506, + 676 + ], + "score": 1.0, + "content": "updates for Async-Opt, which represent similar amounts of computation. Results of this", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 674, + 258, + 686 + ], + "spans": [ + { + "bbox": [ + 105, + 674, + 258, + 686 + ], + "score": 1.0, + "content": "experiment are presented in Figure 8.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 42.5 + }, + { + "type": "text", + "bbox": [ + 108, + 690, + 505, + 713 + ], + "lines": [ + { + "bbox": [ + 106, + 689, + 504, + 703 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 474, + 703 + ], + "score": 1.0, + "content": "Figure 8b shows that Sync-Opt outperforms Async-Opt in test precision: Sync-Opt attains", + "type": "text" + }, + { + "bbox": [ + 474, + 691, + 504, + 701 + ], + "score": 0.92, + "content": "{ \\sim } 0 . 5 \\%", + "type": "inline_equation" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 701, + 505, + 715 + ], + "spans": [ + { + "bbox": [ + 106, + 701, + 320, + 715 + ], + "score": 1.0, + "content": "better test precision than Async-Opt for comparable", + "type": "text" + }, + { + "bbox": [ + 320, + 704, + 347, + 712 + ], + "score": 0.91, + "content": "N + b", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 701, + 505, + 715 + ], + "score": 1.0, + "content": "workers. Furthermore, Sync-Opt con-", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 46.5 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 117, + 721, + 474, + 732 + ], + "lines": [ + { + "bbox": [ + 119, + 719, + 474, + 734 + ], + "spans": [ + { + "bbox": [ + 119, + 719, + 474, + 734 + ], + "score": 1.0, + "content": "3Convergence is defined as the point where maximum test accuracy or lowest test error is reached.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 310, + 762 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 171 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "Hence, there is a trade-off between dropping more stragglers to reduce iteration time, and waiting", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "for more gradients to improve the gradient quality. Consider a hypothetical setting where we have", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 107, + 104, + 506, + 117 + ], + "spans": [ + { + "bbox": [ + 107, + 105, + 167, + 115 + ], + "score": 0.91, + "content": "N + b = 1 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 104, + 415, + 117 + ], + "score": 1.0, + "content": "machines, and we wish to choose the best configuration of", + "type": "text" + }, + { + "bbox": [ + 415, + 105, + 426, + 114 + ], + "score": 0.82, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 104, + 445, + 117 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 446, + 105, + 452, + 114 + ], + "score": 0.69, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 104, + 506, + 117 + ], + "score": 1.0, + "content": "to minimize", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "score": 1.0, + "content": "running time to convergence3. For each configuration, we can estimate the iterations required from", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 285, + 140 + ], + "score": 1.0, + "content": "Figure 5 (linearly interpolating for values of", + "type": "text" + }, + { + "bbox": [ + 285, + 127, + 295, + 136 + ], + "score": 0.81, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 296, + 126, + 505, + 140 + ], + "score": 1.0, + "content": "for which we did not collect data). We can multiply", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 505, + 150 + ], + "score": 1.0, + "content": "this with the mean iteration times (Figure 4) to obtain the running time required to converge for each", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 147, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 147, + 147, + 162 + ], + "score": 1.0, + "content": "setting of", + "type": "text" + }, + { + "bbox": [ + 147, + 149, + 158, + 158 + ], + "score": 0.8, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 158, + 147, + 176, + 162 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 176, + 149, + 182, + 158 + ], + "score": 0.65, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 147, + 397, + 162 + ], + "score": 1.0, + "content": ". These results are shown in Figure 6, indicating that", + "type": "text" + }, + { + "bbox": [ + 397, + 149, + 432, + 159 + ], + "score": 0.85, + "content": "N = 9 6", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 147, + 436, + 162 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 436, + 149, + 462, + 159 + ], + "score": 0.82, + "content": "b = 4", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 147, + 505, + 162 + ], + "score": 1.0, + "content": "converges", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 501, + 172 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 501, + 172 + ], + "score": 1.0, + "content": "fastest. Therefore, this motivates our choice to use a few backup workers for mitigating stragglers.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 82, + 506, + 172 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 187, + 200, + 199 + ], + "lines": [ + { + "bbox": [ + 105, + 186, + 201, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 201, + 201 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 212, + 505, + 245 + ], + "lines": [ + { + "bbox": [ + 105, + 211, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 211, + 505, + 225 + ], + "score": 1.0, + "content": "In this section, we present our empirical comparisons of synchronous and asynchronous distributed", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 222, + 506, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 222, + 506, + 236 + ], + "score": 1.0, + "content": "stochastic optimization algorithms as applied to models such as Inception and PixelCNN. All exper-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 234, + 403, + 246 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 403, + 246 + ], + "score": 1.0, + "content": "iments in this paper are using the TensorFlow system (Abadi et al., 2015).", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10, + "bbox_fs": [ + 105, + 211, + 506, + 246 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 258, + 434, + 270 + ], + "lines": [ + { + "bbox": [ + 105, + 258, + 436, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 258, + 436, + 271 + ], + "score": 1.0, + "content": "4.1 METRICS OF COMPARISON: FASTER CONVERGENCE, BETTER OPTIMUM", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 279, + 505, + 324 + ], + "lines": [ + { + "bbox": [ + 106, + 279, + 505, + 291 + ], + "spans": [ + { + "bbox": [ + 106, + 279, + 505, + 291 + ], + "score": 1.0, + "content": "We are interested in two metrics of comparison for our empirical validation: (1) test error or ac-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 290, + 505, + 303 + ], + "spans": [ + { + "bbox": [ + 106, + 290, + 505, + 303 + ], + "score": 1.0, + "content": "curacy, and (2) speed of convergence3. We point out that for non-convex deep learning models,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 300, + 506, + 315 + ], + "spans": [ + { + "bbox": [ + 105, + 300, + 506, + 315 + ], + "score": 1.0, + "content": "it is possible to converge faster to a poorer local optimum. Here we show a simple example with", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 312, + 266, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 312, + 266, + 325 + ], + "score": 1.0, + "content": "Inception using different learning rates.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 14.5, + "bbox_fs": [ + 105, + 279, + 506, + 325 + ] + }, + { + "type": "table", + "bbox": [ + 106, + 354, + 246, + 437 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 354, + 246, + 437 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 354, + 246, + 437 + ], + "spans": [ + { + "bbox": [ + 106, + 354, + 246, + 437 + ], + "score": 0.955, + "html": "
Initial rate 20Test precision at convergenceEpochs to converge
1.125 2.2577.29% 77.75%52628 65811
4.5
9.078.15%76209
78.17%77235
", + "type": "table", + "image_path": "a5721568a454d9eb4d6b58098695145714eed7c25b8fae79b2905aa7d541c982.jpg" + } + ] + } + ], + "index": 18.0, + "virtual_lines": [ + { + "bbox": [ + 106, + 354, + 246, + 395.5 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 106, + 395.5, + 246, + 437.0 + ], + "spans": [], + "index": 19 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 106, + 445, + 243, + 506 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 445, + 244, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 445, + 244, + 457 + ], + "score": 1.0, + "content": "Table 2: Test accuracies at con-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 456, + 244, + 466 + ], + "spans": [ + { + "bbox": [ + 106, + 456, + 244, + 466 + ], + "score": 1.0, + "content": "vergence and number of epochs to", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 465, + 244, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 244, + 478 + ], + "score": 1.0, + "content": "converge for different initial learning", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 476, + 243, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 476, + 127, + 487 + ], + "score": 1.0, + "content": "rates", + "type": "text" + }, + { + "bbox": [ + 127, + 478, + 137, + 486 + ], + "score": 0.82, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 137, + 476, + 243, + 487 + ], + "score": 1.0, + "content": ". Low initial learning rates", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 486, + 244, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 244, + 497 + ], + "score": 1.0, + "content": "result in faster convergence to poorer", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 496, + 163, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 163, + 507 + ], + "score": 1.0, + "content": "local optimum.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24.5 + } + ], + "index": 21.25 + }, + { + "type": "image", + "bbox": [ + 250, + 335, + 499, + 446 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 250, + 335, + 499, + 446 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 250, + 335, + 499, + 446 + ], + "spans": [ + { + "bbox": [ + 250, + 335, + 499, + 446 + ], + "score": 0.97, + "type": "image", + "image_path": "cf7dd8a2918112ad1401df8582e7cb61ac45e2309e2c05a587c225cae4d880a5.jpg" + } + ] + } + ], + "index": 20, + "virtual_lines": [ + { + "bbox": [ + 250, + 335, + 499, + 372.0 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 250, + 372.0, + 499, + 409.0 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 250, + 409.0, + 499, + 446.0 + ], + "spans": [], + "index": 21 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 249, + 456, + 504, + 506 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 248, + 455, + 505, + 467 + ], + "spans": [ + { + "bbox": [ + 248, + 455, + 483, + 467 + ], + "score": 1.0, + "content": "Figure 7: Convergence of Sync-Opt on Inception model using", + "type": "text" + }, + { + "bbox": [ + 483, + 456, + 505, + 466 + ], + "score": 0.83, + "content": "N =", + "type": "inline_equation" + } + ], + "index": 28 + }, + { + "bbox": [ + 248, + 464, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 248, + 464, + 311, + 478 + ], + "score": 1.0, + "content": "100 workers and", + "type": "text" + }, + { + "bbox": [ + 312, + 466, + 334, + 475 + ], + "score": 0.9, + "content": "b = 6", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 464, + 491, + 478 + ], + "score": 1.0, + "content": "backups, with varying initial learning rates", + "type": "text" + }, + { + "bbox": [ + 491, + 468, + 501, + 477 + ], + "score": 0.79, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 464, + 505, + 478 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 248, + 475, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 248, + 475, + 311, + 487 + ], + "score": 1.0, + "content": "To reach a lower", + "type": "text" + }, + { + "bbox": [ + 311, + 478, + 317, + 485 + ], + "score": 0.6, + "content": "\\epsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 475, + 392, + 487 + ], + "score": 1.0, + "content": "test precision, small", + "type": "text" + }, + { + "bbox": [ + 392, + 477, + 402, + 486 + ], + "score": 0.84, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 475, + 505, + 487 + ], + "score": 1.0, + "content": "’s require fewer epochs than", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 248, + 486, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 248, + 486, + 268, + 497 + ], + "score": 1.0, + "content": "large", + "type": "text" + }, + { + "bbox": [ + 269, + 487, + 279, + 496 + ], + "score": 0.83, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 486, + 347, + 497 + ], + "score": 1.0, + "content": "’s. However, small", + "type": "text" + }, + { + "bbox": [ + 347, + 487, + 357, + 496 + ], + "score": 0.85, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 358, + 486, + 451, + 497 + ], + "score": 1.0, + "content": "’s either fail to attain high", + "type": "text" + }, + { + "bbox": [ + 451, + 488, + 457, + 495 + ], + "score": 0.68, + "content": "\\epsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 486, + 505, + 497 + ], + "score": 1.0, + "content": "precision, or", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 249, + 496, + 376, + 507 + ], + "spans": [ + { + "bbox": [ + 249, + 496, + 357, + 507 + ], + "score": 1.0, + "content": "take more epochs than higher", + "type": "text" + }, + { + "bbox": [ + 357, + 497, + 367, + 506 + ], + "score": 0.82, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 496, + 376, + 507 + ], + "score": 1.0, + "content": "’s.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30 + } + ], + "index": 25.0 + }, + { + "type": "text", + "bbox": [ + 107, + 518, + 505, + 585 + ], + "lines": [ + { + "bbox": [ + 105, + 516, + 504, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 256, + 533 + ], + "score": 1.0, + "content": "We ran Sync-Opt on Inception with", + "type": "text" + }, + { + "bbox": [ + 257, + 519, + 299, + 529 + ], + "score": 0.9, + "content": "N = 1 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 516, + 319, + 533 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 319, + 519, + 347, + 529 + ], + "score": 0.9, + "content": "b = 6", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 516, + 492, + 533 + ], + "score": 1.0, + "content": ", but varied the initial learning rate", + "type": "text" + }, + { + "bbox": [ + 493, + 521, + 504, + 530 + ], + "score": 0.82, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 529, + 506, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 506, + 542 + ], + "score": 1.0, + "content": "between 1.125 and 9.0. (Learning rates are exponentially decreased with iterations.) Table 2 shows", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 540, + 505, + 553 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 156, + 553 + ], + "score": 1.0, + "content": "that smaller", + "type": "text" + }, + { + "bbox": [ + 156, + 542, + 168, + 552 + ], + "score": 0.85, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 540, + 505, + 553 + ], + "score": 1.0, + "content": "converge faster, but to poorer test precisions. Focusing on speed on an early phase", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 551, + 505, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 505, + 564 + ], + "score": 1.0, + "content": "of training could lead to misleading conclusions if we fail to account for eventual convergence.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 562, + 505, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 562, + 273, + 575 + ], + "score": 1.0, + "content": "For example, Figure 3b shows that using", + "type": "text" + }, + { + "bbox": [ + 274, + 563, + 323, + 574 + ], + "score": 0.9, + "content": "\\gamma _ { 0 } = 1 . 1 2 5", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 562, + 357, + 575 + ], + "score": 1.0, + "content": "reaches", + "type": "text" + }, + { + "bbox": [ + 357, + 562, + 396, + 573 + ], + "score": 0.91, + "content": "\\epsilon = 7 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 562, + 437, + 575 + ], + "score": 1.0, + "content": "precision", + "type": "text" + }, + { + "bbox": [ + 437, + 563, + 459, + 573 + ], + "score": 0.86, + "content": "1 . 5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 459, + 562, + 505, + 575 + ], + "score": 1.0, + "content": "faster than", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 573, + 412, + 586 + ], + "spans": [ + { + "bbox": [ + 106, + 574, + 143, + 585 + ], + "score": 0.91, + "content": "\\gamma _ { 0 } = 4 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 573, + 214, + 586 + ], + "score": 1.0, + "content": ", but is slower for", + "type": "text" + }, + { + "bbox": [ + 214, + 573, + 264, + 585 + ], + "score": 0.91, + "content": "\\epsilon = 7 7 . 7 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 573, + 412, + 586 + ], + "score": 1.0, + "content": ", and fails to reach higher precisions.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 516, + 506, + 586 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 598, + 179, + 609 + ], + "lines": [ + { + "bbox": [ + 105, + 598, + 180, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 180, + 611 + ], + "score": 1.0, + "content": "4.2 INCEPTION", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 107, + 618, + 505, + 685 + ], + "lines": [ + { + "bbox": [ + 106, + 619, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 106, + 619, + 505, + 632 + ], + "score": 1.0, + "content": "We conducted experiments on the Inception model (Szegedy et al., 2016) trained on ImageNet Chal-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 629, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 505, + 643 + ], + "score": 1.0, + "content": "lenge dataset (Russakovsky et al., 2015), where the task is to classify images out of 1000 categories.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 641, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 271, + 654 + ], + "score": 1.0, + "content": "We used several configurations, varying", + "type": "text" + }, + { + "bbox": [ + 271, + 641, + 299, + 651 + ], + "score": 0.9, + "content": "N + b", + "type": "inline_equation" + }, + { + "bbox": [ + 299, + 641, + 505, + 654 + ], + "score": 1.0, + "content": "from 53 to 212 workers. Additional details of the", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 651, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 505, + 664 + ], + "score": 1.0, + "content": "training are provided in Appendix A.3. An epoch is a synchronous iteration for Sync-Opt, or a full", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 662, + 506, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 662, + 137, + 676 + ], + "score": 1.0, + "content": "pass of", + "type": "text" + }, + { + "bbox": [ + 137, + 663, + 148, + 673 + ], + "score": 0.78, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 148, + 662, + 506, + 676 + ], + "score": 1.0, + "content": "updates for Async-Opt, which represent similar amounts of computation. Results of this", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 674, + 258, + 686 + ], + "spans": [ + { + "bbox": [ + 105, + 674, + 258, + 686 + ], + "score": 1.0, + "content": "experiment are presented in Figure 8.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 42.5, + "bbox_fs": [ + 105, + 619, + 506, + 686 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 690, + 505, + 713 + ], + "lines": [ + { + "bbox": [ + 106, + 689, + 504, + 703 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 474, + 703 + ], + "score": 1.0, + "content": "Figure 8b shows that Sync-Opt outperforms Async-Opt in test precision: Sync-Opt attains", + "type": "text" + }, + { + "bbox": [ + 474, + 691, + 504, + 701 + ], + "score": 0.92, + "content": "{ \\sim } 0 . 5 \\%", + "type": "inline_equation" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 701, + 505, + 715 + ], + "spans": [ + { + "bbox": [ + 106, + 701, + 320, + 715 + ], + "score": 1.0, + "content": "better test precision than Async-Opt for comparable", + "type": "text" + }, + { + "bbox": [ + 320, + 704, + 347, + 712 + ], + "score": 0.91, + "content": "N + b", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 701, + 505, + 715 + ], + "score": 1.0, + "content": "workers. Furthermore, Sync-Opt con-", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 402, + 506, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 506, + 415 + ], + "score": 1.0, + "content": "verges 6h and 18h faster than Async-Opt for 106 and 212 workers respectively, and is 3h slower", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 412, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 506, + 426 + ], + "score": 1.0, + "content": "when 53 workers are used, as seen in Figure 8d. This difference in speed is largely due to the fewer", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 424, + 466, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 466, + 437 + ], + "score": 1.0, + "content": "epochs (Figure 8c) needed by Sync-Opt, but comparable or better epoch time (Figure 8e).", + "type": "text", + "cross_page": true + } + ], + "index": 7 + } + ], + "index": 46.5, + "bbox_fs": [ + 106, + 689, + 505, + 715 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 110, + 80, + 500, + 345 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 110, + 80, + 500, + 345 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 80, + 500, + 345 + ], + "spans": [ + { + "bbox": [ + 110, + 80, + 500, + 345 + ], + "score": 0.975, + "type": "image", + "image_path": "4a2795f1f53e652a98aa43d466d16efa8ffdf2c2db7dc3f06c9317fb0d07f46a.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 110, + 80, + 500, + 168.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 110, + 168.33333333333331, + 500, + 256.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 110, + 256.66666666666663, + 500, + 344.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 354, + 504, + 375 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 353, + 504, + 365 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 504, + 365 + ], + "score": 1.0, + "content": "Figure 8: Convergence of Sync-Opt and Async-Opt on Inception model using varying number of machines.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 364, + 440, + 376 + ], + "spans": [ + { + "bbox": [ + 106, + 364, + 440, + 376 + ], + "score": 1.0, + "content": "Sync-Opt with backup workers converge faster, with fewer epochs, to higher test accuracies.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 107, + 402, + 505, + 436 + ], + "lines": [ + { + "bbox": [ + 105, + 402, + 506, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 506, + 415 + ], + "score": 1.0, + "content": "verges 6h and 18h faster than Async-Opt for 106 and 212 workers respectively, and is 3h slower", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 412, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 506, + 426 + ], + "score": 1.0, + "content": "when 53 workers are used, as seen in Figure 8d. This difference in speed is largely due to the fewer", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 424, + 466, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 466, + 437 + ], + "score": 1.0, + "content": "epochs (Figure 8c) needed by Sync-Opt, but comparable or better epoch time (Figure 8e).", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "title", + "bbox": [ + 108, + 455, + 244, + 466 + ], + "lines": [ + { + "bbox": [ + 105, + 454, + 245, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 245, + 468 + ], + "score": 1.0, + "content": "4.3 PIXELCNN EXPERIMENTS", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 478, + 505, + 523 + ], + "lines": [ + { + "bbox": [ + 105, + 477, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 505, + 492 + ], + "score": 1.0, + "content": "The second model we experimented on is PixelCNN (Oord et al., 2016), a conditional image gener-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 489, + 504, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 504, + 501 + ], + "score": 1.0, + "content": "ation deep neural network, which we train on the CIFAR-10 (Krizhevsky & Hinton, 2009) dataset.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 500, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 179, + 514 + ], + "score": 1.0, + "content": "Configurations of", + "type": "text" + }, + { + "bbox": [ + 179, + 501, + 247, + 512 + ], + "score": 0.88, + "content": "N + b = 1 , 8 , 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 247, + 500, + 448, + 514 + ], + "score": 1.0, + "content": "workers were used; for Sync-Opt, we always used", + "type": "text" + }, + { + "bbox": [ + 449, + 501, + 473, + 511 + ], + "score": 0.89, + "content": "b = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 500, + 505, + 514 + ], + "score": 1.0, + "content": "backup", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 512, + 337, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 337, + 524 + ], + "score": 1.0, + "content": "worker. Additional details are provided in Appendix A.4.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5 + }, + { + "type": "image", + "bbox": [ + 109, + 541, + 501, + 698 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 541, + 501, + 698 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 109, + 541, + 501, + 698 + ], + "spans": [ + { + "bbox": [ + 109, + 541, + 501, + 698 + ], + "score": 0.968, + "type": "image", + "image_path": "c0603f807e6115ff2ee2ef1f99ab3da81f0e47d7e4e735a38c20bae4c9c188e1.jpg" + } + ] + } + ], + "index": 14, + "virtual_lines": [ + { + "bbox": [ + 109, + 541, + 501, + 593.3333333333334 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 109, + 593.3333333333334, + 501, + 645.6666666666667 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 109, + 645.6666666666667, + 501, + 698.0000000000001 + ], + "spans": [], + "index": 15 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 708, + 504, + 730 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 707, + 505, + 720 + ], + "spans": [ + { + "bbox": [ + 106, + 707, + 505, + 720 + ], + "score": 1.0, + "content": "Figure 9: Convergence of synchronous and asynchronous training on PixelCNN model. Sync-Opt achieves", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 718, + 318, + 730 + ], + "spans": [ + { + "bbox": [ + 106, + 718, + 318, + 730 + ], + "score": 1.0, + "content": "lower negative log likelihood in less time than Async-Opt.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16.5 + } + ], + "index": 15.25 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 110, + 80, + 500, + 345 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 110, + 80, + 500, + 345 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 80, + 500, + 345 + ], + "spans": [ + { + "bbox": [ + 110, + 80, + 500, + 345 + ], + "score": 0.975, + "type": "image", + "image_path": "4a2795f1f53e652a98aa43d466d16efa8ffdf2c2db7dc3f06c9317fb0d07f46a.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 110, + 80, + 500, + 168.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 110, + 168.33333333333331, + 500, + 256.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 110, + 256.66666666666663, + 500, + 344.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 354, + 504, + 375 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 353, + 504, + 365 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 504, + 365 + ], + "score": 1.0, + "content": "Figure 8: Convergence of Sync-Opt and Async-Opt on Inception model using varying number of machines.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 364, + 440, + 376 + ], + "spans": [ + { + "bbox": [ + 106, + 364, + 440, + 376 + ], + "score": 1.0, + "content": "Sync-Opt with backup workers converge faster, with fewer epochs, to higher test accuracies.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 107, + 402, + 505, + 436 + ], + "lines": [], + "index": 6, + "bbox_fs": [ + 105, + 402, + 506, + 437 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 108, + 455, + 244, + 466 + ], + "lines": [ + { + "bbox": [ + 105, + 454, + 245, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 245, + 468 + ], + "score": 1.0, + "content": "4.3 PIXELCNN EXPERIMENTS", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 478, + 505, + 523 + ], + "lines": [ + { + "bbox": [ + 105, + 477, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 505, + 492 + ], + "score": 1.0, + "content": "The second model we experimented on is PixelCNN (Oord et al., 2016), a conditional image gener-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 489, + 504, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 504, + 501 + ], + "score": 1.0, + "content": "ation deep neural network, which we train on the CIFAR-10 (Krizhevsky & Hinton, 2009) dataset.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 500, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 179, + 514 + ], + "score": 1.0, + "content": "Configurations of", + "type": "text" + }, + { + "bbox": [ + 179, + 501, + 247, + 512 + ], + "score": 0.88, + "content": "N + b = 1 , 8 , 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 247, + 500, + 448, + 514 + ], + "score": 1.0, + "content": "workers were used; for Sync-Opt, we always used", + "type": "text" + }, + { + "bbox": [ + 449, + 501, + 473, + 511 + ], + "score": 0.89, + "content": "b = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 500, + 505, + 514 + ], + "score": 1.0, + "content": "backup", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 512, + 337, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 337, + 524 + ], + "score": 1.0, + "content": "worker. Additional details are provided in Appendix A.4.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 477, + 505, + 524 + ] + }, + { + "type": "image", + "bbox": [ + 109, + 541, + 501, + 698 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 541, + 501, + 698 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 109, + 541, + 501, + 698 + ], + "spans": [ + { + "bbox": [ + 109, + 541, + 501, + 698 + ], + "score": 0.968, + "type": "image", + "image_path": "c0603f807e6115ff2ee2ef1f99ab3da81f0e47d7e4e735a38c20bae4c9c188e1.jpg" + } + ] + } + ], + "index": 14, + "virtual_lines": [ + { + "bbox": [ + 109, + 541, + 501, + 593.3333333333334 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 109, + 593.3333333333334, + 501, + 645.6666666666667 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 109, + 645.6666666666667, + 501, + 698.0000000000001 + ], + "spans": [], + "index": 15 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 708, + 504, + 730 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 707, + 505, + 720 + ], + "spans": [ + { + "bbox": [ + 106, + 707, + 505, + 720 + ], + "score": 1.0, + "content": "Figure 9: Convergence of synchronous and asynchronous training on PixelCNN model. Sync-Opt achieves", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 718, + 318, + 730 + ], + "spans": [ + { + "bbox": [ + 106, + 718, + 318, + 730 + ], + "score": 1.0, + "content": "lower negative log likelihood in less time than Async-Opt.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16.5 + } + ], + "index": 15.25 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 137 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Convergence of the test negative log likelihood (NLL) on PixelCNN is shown in Figure 9a, where", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 92, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 92, + 505, + 106 + ], + "score": 1.0, + "content": "lower is better. Observe that Sync-Opt obtains lower NLL than Async-Opt; in fact, Async-Opt", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 504, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 297, + 117 + ], + "score": 1.0, + "content": "is even outperformed by serial RMSProp with", + "type": "text" + }, + { + "bbox": [ + 298, + 105, + 329, + 114 + ], + "score": 0.9, + "content": "N = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 104, + 493, + 117 + ], + "score": 1.0, + "content": "worker, with degrading performance as", + "type": "text" + }, + { + "bbox": [ + 493, + 105, + 504, + 114 + ], + "score": 0.73, + "content": "N", + "type": "inline_equation" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 385, + 128 + ], + "score": 1.0, + "content": "increases from 8 to 16. Figure 9b further shows the time taken to reach", + "type": "text" + }, + { + "bbox": [ + 386, + 117, + 392, + 125 + ], + "score": 0.33, + "content": "\\epsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 114, + 505, + 128 + ], + "score": 1.0, + "content": "test NLL. Sync-Opt reduces", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 125, + 482, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 125, + 175, + 140 + ], + "score": 1.0, + "content": "the time to reach", + "type": "text" + }, + { + "bbox": [ + 176, + 127, + 217, + 137 + ], + "score": 0.84, + "content": "\\epsilon = 2 . 1 4 5", + "type": "inline_equation" + }, + { + "bbox": [ + 218, + 125, + 272, + 140 + ], + "score": 1.0, + "content": "from 247h to", + "type": "text" + }, + { + "bbox": [ + 273, + 127, + 297, + 137 + ], + "score": 0.43, + "content": "5 8 . 3 \\mathrm { h }", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 125, + 482, + 140 + ], + "score": 1.0, + "content": "; this NLL is not even achieved by Async-Opt.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2 + }, + { + "type": "title", + "bbox": [ + 108, + 155, + 211, + 167 + ], + "lines": [ + { + "bbox": [ + 105, + 154, + 213, + 169 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 213, + 169 + ], + "score": 1.0, + "content": "5 RELATED WORK", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 107, + 180, + 505, + 236 + ], + "lines": [ + { + "bbox": [ + 105, + 180, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 105, + 180, + 505, + 194 + ], + "score": 1.0, + "content": "Multicore and distributed optimization algorithms have received much attention in recent years.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 191, + 505, + 204 + ], + "spans": [ + { + "bbox": [ + 106, + 191, + 505, + 204 + ], + "score": 1.0, + "content": "Asynchronous algorithms include Recht et al. (2011); Duchi et al. (2013); Zhang et al. (2015a);", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 201, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 201, + 505, + 216 + ], + "score": 1.0, + "content": "Reddi et al. (2015); Leblond et al. (2016). Implementations of asynchronous optimization include", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 213, + 505, + 226 + ], + "spans": [ + { + "bbox": [ + 105, + 213, + 505, + 226 + ], + "score": 1.0, + "content": "Xing et al. (2015); Li et al. (2014); Chilimbi et al. (2014). Attempts have also been made in Zinke-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 223, + 477, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 223, + 477, + 237 + ], + "score": 1.0, + "content": "vich et al. (2010) and Zhang & Jordan (2015) to algorithmically improve synchronous SGD.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 241, + 504, + 307 + ], + "lines": [ + { + "bbox": [ + 105, + 239, + 506, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 506, + 255 + ], + "score": 1.0, + "content": "An alternative solution, “softsync”, was presented in Zhang et al. (2015b), which proposed batching", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 252, + 506, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 252, + 506, + 266 + ], + "score": 1.0, + "content": "gradients from multiple machines before performing an asynchronous SGD update, thereby reducing", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 262, + 506, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 506, + 277 + ], + "score": 1.0, + "content": "the effective staleness of gradients. Similar to our proposal, softsync avoids stragglers by not forcing", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 274, + 506, + 287 + ], + "spans": [ + { + "bbox": [ + 106, + 274, + 506, + 287 + ], + "score": 1.0, + "content": "updates to wait for the slowest worker. However, softsync allows the use of stale gradients but we", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 284, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 506, + 299 + ], + "score": 1.0, + "content": "do not. The two solutions provide different explorations of the trade-off between high accuracy (by", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 296, + 376, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 376, + 309 + ], + "score": 1.0, + "content": "minimizing staleness) and fast throughput (by avoiding stragglers).", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 107, + 313, + 504, + 368 + ], + "lines": [ + { + "bbox": [ + 107, + 313, + 505, + 325 + ], + "spans": [ + { + "bbox": [ + 107, + 313, + 505, + 325 + ], + "score": 1.0, + "content": "Watcharapichat et al. (2016) introduces a distributed deep learning system without parameter", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 324, + 506, + 336 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 506, + 336 + ], + "score": 1.0, + "content": "servers, by having workers interleave gradient computation and communication in a round-robin", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 335, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 505, + 347 + ], + "score": 1.0, + "content": "pattern. Like Async-Opt, this approach suffers from staleness. We also note that in principle, work-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 346, + 506, + 359 + ], + "spans": [ + { + "bbox": [ + 105, + 346, + 506, + 359 + ], + "score": 1.0, + "content": "ers in Sync-Opt can double as parameter servers and execute the update operations and avoid the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 357, + 374, + 369 + ], + "spans": [ + { + "bbox": [ + 106, + 357, + 374, + 369 + ], + "score": 1.0, + "content": "need to partition hardware resources between workers and servers.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 374, + 505, + 407 + ], + "lines": [ + { + "bbox": [ + 105, + 372, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 505, + 387 + ], + "score": 1.0, + "content": "Das et al. (2016) analyzes distributed stochastic optimization and optimizes the system by solving", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 385, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 505, + 397 + ], + "score": 1.0, + "content": "detailed system balance equations. We believe this approach is complimentary to our work, and", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 396, + 459, + 408 + ], + "spans": [ + { + "bbox": [ + 106, + 396, + 459, + 408 + ], + "score": 1.0, + "content": "could potentially be applied to guide the choice of systems configurations for Sync-Opt.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 412, + 505, + 457 + ], + "lines": [ + { + "bbox": [ + 106, + 413, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 505, + 425 + ], + "score": 1.0, + "content": "Keskar et al. (2016) suggests that large batch sizes for synchronous stochastic optimization leads to", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 424, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 491, + 436 + ], + "score": 1.0, + "content": "poorer generalization. Our effective batch size increases linearly with the number of workers", + "type": "text" + }, + { + "bbox": [ + 491, + 424, + 501, + 434 + ], + "score": 0.76, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 424, + 505, + 436 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 434, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 505, + 447 + ], + "score": 1.0, + "content": "However, we did not observe this effect in our experiments; we believe we are not yet in the large", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 446, + 315, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 315, + 457 + ], + "score": 1.0, + "content": "batch size regime examined by Keskar et al. (2016).", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5 + }, + { + "type": "title", + "bbox": [ + 107, + 474, + 303, + 487 + ], + "lines": [ + { + "bbox": [ + 105, + 472, + 304, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 304, + 489 + ], + "score": 1.0, + "content": "6 CONCLUSION AND FUTURE WORK", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 500, + 504, + 555 + ], + "lines": [ + { + "bbox": [ + 106, + 500, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 505, + 512 + ], + "score": 1.0, + "content": "Distributed training strategies for deep learning architectures will become ever more important as", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 511, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 505, + 523 + ], + "score": 1.0, + "content": "the size of datasets increases. In this work, we have shown how both synchronous and asynchronous", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 522, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 522, + 505, + 534 + ], + "score": 1.0, + "content": "distributed stochastic optimization suffer from their respective weaknesses of stragglers and stal-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 531, + 506, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 506, + 547 + ], + "score": 1.0, + "content": "eness. This has motivated our development of synchronous stochastic optimization with backup", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 542, + 351, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 351, + 558 + ], + "score": 1.0, + "content": "workers, which we show to be a viable and scalable strategy.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 560, + 505, + 627 + ], + "lines": [ + { + "bbox": [ + 105, + 560, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 505, + 573 + ], + "score": 1.0, + "content": "We are currently experimenting with different kinds of datasets, including word-level language mod-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 571, + 505, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 571, + 505, + 585 + ], + "score": 1.0, + "content": "els where parts of the model (the embedding layers) are often very sparse, which involves very", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 582, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 595 + ], + "score": 1.0, + "content": "different communication constraints. We are also working on further improving the performance", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 594, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 106, + 594, + 505, + 605 + ], + "score": 1.0, + "content": "of synchronous training like combining gradients from multiple workers sharing the same machine", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "score": 1.0, + "content": "before sending them to the parameter servers to reduce the communication overhead. An alternative", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 615, + 380, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 380, + 627 + ], + "score": 1.0, + "content": "of using time-outs instead of backup workers is also being explored.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 37.5 + }, + { + "type": "title", + "bbox": [ + 107, + 644, + 175, + 655 + ], + "lines": [ + { + "bbox": [ + 106, + 643, + 176, + 656 + ], + "spans": [ + { + "bbox": [ + 106, + 643, + 176, + 656 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 108, + 661, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 661, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 106, + 661, + 505, + 673 + ], + "score": 1.0, + "content": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado,", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 670, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 115, + 670, + 505, + 685 + ], + "score": 1.0, + "content": "Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 114, + 679, + 506, + 695 + ], + "spans": [ + { + "bbox": [ + 114, + 679, + 506, + 695 + ], + "score": 1.0, + "content": "Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 691, + 505, + 703 + ], + "spans": [ + { + "bbox": [ + 115, + 691, + 505, + 703 + ], + "score": 1.0, + "content": "Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit ´", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 115, + 699, + 506, + 715 + ], + "spans": [ + { + "bbox": [ + 115, + 699, + 506, + 715 + ], + "score": 1.0, + "content": "Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, ´", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 116, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 116, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow:", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 115, + 721, + 489, + 733 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 489, + 733 + ], + "score": 1.0, + "content": "Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow.org/.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 45 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 25, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 25, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 761 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 761 + ], + "score": 1.0, + "content": "8", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 137 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Convergence of the test negative log likelihood (NLL) on PixelCNN is shown in Figure 9a, where", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 92, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 92, + 505, + 106 + ], + "score": 1.0, + "content": "lower is better. Observe that Sync-Opt obtains lower NLL than Async-Opt; in fact, Async-Opt", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 504, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 297, + 117 + ], + "score": 1.0, + "content": "is even outperformed by serial RMSProp with", + "type": "text" + }, + { + "bbox": [ + 298, + 105, + 329, + 114 + ], + "score": 0.9, + "content": "N = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 104, + 493, + 117 + ], + "score": 1.0, + "content": "worker, with degrading performance as", + "type": "text" + }, + { + "bbox": [ + 493, + 105, + 504, + 114 + ], + "score": 0.73, + "content": "N", + "type": "inline_equation" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 385, + 128 + ], + "score": 1.0, + "content": "increases from 8 to 16. Figure 9b further shows the time taken to reach", + "type": "text" + }, + { + "bbox": [ + 386, + 117, + 392, + 125 + ], + "score": 0.33, + "content": "\\epsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 114, + 505, + 128 + ], + "score": 1.0, + "content": "test NLL. Sync-Opt reduces", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 125, + 482, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 125, + 175, + 140 + ], + "score": 1.0, + "content": "the time to reach", + "type": "text" + }, + { + "bbox": [ + 176, + 127, + 217, + 137 + ], + "score": 0.84, + "content": "\\epsilon = 2 . 1 4 5", + "type": "inline_equation" + }, + { + "bbox": [ + 218, + 125, + 272, + 140 + ], + "score": 1.0, + "content": "from 247h to", + "type": "text" + }, + { + "bbox": [ + 273, + 127, + 297, + 137 + ], + "score": 0.43, + "content": "5 8 . 3 \\mathrm { h }", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 125, + 482, + 140 + ], + "score": 1.0, + "content": "; this NLL is not even achieved by Async-Opt.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2, + "bbox_fs": [ + 105, + 82, + 505, + 140 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 155, + 211, + 167 + ], + "lines": [ + { + "bbox": [ + 105, + 154, + 213, + 169 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 213, + 169 + ], + "score": 1.0, + "content": "5 RELATED WORK", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 107, + 180, + 505, + 236 + ], + "lines": [ + { + "bbox": [ + 105, + 180, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 105, + 180, + 505, + 194 + ], + "score": 1.0, + "content": "Multicore and distributed optimization algorithms have received much attention in recent years.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 191, + 505, + 204 + ], + "spans": [ + { + "bbox": [ + 106, + 191, + 505, + 204 + ], + "score": 1.0, + "content": "Asynchronous algorithms include Recht et al. (2011); Duchi et al. (2013); Zhang et al. (2015a);", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 201, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 201, + 505, + 216 + ], + "score": 1.0, + "content": "Reddi et al. (2015); Leblond et al. (2016). Implementations of asynchronous optimization include", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 213, + 505, + 226 + ], + "spans": [ + { + "bbox": [ + 105, + 213, + 505, + 226 + ], + "score": 1.0, + "content": "Xing et al. (2015); Li et al. (2014); Chilimbi et al. (2014). Attempts have also been made in Zinke-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 223, + 477, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 223, + 477, + 237 + ], + "score": 1.0, + "content": "vich et al. (2010) and Zhang & Jordan (2015) to algorithmically improve synchronous SGD.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 180, + 505, + 237 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 241, + 504, + 307 + ], + "lines": [ + { + "bbox": [ + 105, + 239, + 506, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 506, + 255 + ], + "score": 1.0, + "content": "An alternative solution, “softsync”, was presented in Zhang et al. (2015b), which proposed batching", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 252, + 506, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 252, + 506, + 266 + ], + "score": 1.0, + "content": "gradients from multiple machines before performing an asynchronous SGD update, thereby reducing", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 262, + 506, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 506, + 277 + ], + "score": 1.0, + "content": "the effective staleness of gradients. Similar to our proposal, softsync avoids stragglers by not forcing", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 274, + 506, + 287 + ], + "spans": [ + { + "bbox": [ + 106, + 274, + 506, + 287 + ], + "score": 1.0, + "content": "updates to wait for the slowest worker. However, softsync allows the use of stale gradients but we", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 284, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 506, + 299 + ], + "score": 1.0, + "content": "do not. The two solutions provide different explorations of the trade-off between high accuracy (by", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 296, + 376, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 376, + 309 + ], + "score": 1.0, + "content": "minimizing staleness) and fast throughput (by avoiding stragglers).", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13.5, + "bbox_fs": [ + 105, + 239, + 506, + 309 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 313, + 504, + 368 + ], + "lines": [ + { + "bbox": [ + 107, + 313, + 505, + 325 + ], + "spans": [ + { + "bbox": [ + 107, + 313, + 505, + 325 + ], + "score": 1.0, + "content": "Watcharapichat et al. (2016) introduces a distributed deep learning system without parameter", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 324, + 506, + 336 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 506, + 336 + ], + "score": 1.0, + "content": "servers, by having workers interleave gradient computation and communication in a round-robin", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 335, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 505, + 347 + ], + "score": 1.0, + "content": "pattern. Like Async-Opt, this approach suffers from staleness. We also note that in principle, work-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 346, + 506, + 359 + ], + "spans": [ + { + "bbox": [ + 105, + 346, + 506, + 359 + ], + "score": 1.0, + "content": "ers in Sync-Opt can double as parameter servers and execute the update operations and avoid the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 357, + 374, + 369 + ], + "spans": [ + { + "bbox": [ + 106, + 357, + 374, + 369 + ], + "score": 1.0, + "content": "need to partition hardware resources between workers and servers.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19, + "bbox_fs": [ + 105, + 313, + 506, + 369 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 374, + 505, + 407 + ], + "lines": [ + { + "bbox": [ + 105, + 372, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 505, + 387 + ], + "score": 1.0, + "content": "Das et al. (2016) analyzes distributed stochastic optimization and optimizes the system by solving", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 385, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 505, + 397 + ], + "score": 1.0, + "content": "detailed system balance equations. We believe this approach is complimentary to our work, and", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 396, + 459, + 408 + ], + "spans": [ + { + "bbox": [ + 106, + 396, + 459, + 408 + ], + "score": 1.0, + "content": "could potentially be applied to guide the choice of systems configurations for Sync-Opt.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 372, + 505, + 408 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 412, + 505, + 457 + ], + "lines": [ + { + "bbox": [ + 106, + 413, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 505, + 425 + ], + "score": 1.0, + "content": "Keskar et al. (2016) suggests that large batch sizes for synchronous stochastic optimization leads to", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 424, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 491, + 436 + ], + "score": 1.0, + "content": "poorer generalization. Our effective batch size increases linearly with the number of workers", + "type": "text" + }, + { + "bbox": [ + 491, + 424, + 501, + 434 + ], + "score": 0.76, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 424, + 505, + 436 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 434, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 505, + 447 + ], + "score": 1.0, + "content": "However, we did not observe this effect in our experiments; we believe we are not yet in the large", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 446, + 315, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 315, + 457 + ], + "score": 1.0, + "content": "batch size regime examined by Keskar et al. (2016).", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 413, + 505, + 457 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 474, + 303, + 487 + ], + "lines": [ + { + "bbox": [ + 105, + 472, + 304, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 304, + 489 + ], + "score": 1.0, + "content": "6 CONCLUSION AND FUTURE WORK", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 500, + 504, + 555 + ], + "lines": [ + { + "bbox": [ + 106, + 500, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 505, + 512 + ], + "score": 1.0, + "content": "Distributed training strategies for deep learning architectures will become ever more important as", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 511, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 505, + 523 + ], + "score": 1.0, + "content": "the size of datasets increases. In this work, we have shown how both synchronous and asynchronous", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 522, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 522, + 505, + 534 + ], + "score": 1.0, + "content": "distributed stochastic optimization suffer from their respective weaknesses of stragglers and stal-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 531, + 506, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 506, + 547 + ], + "score": 1.0, + "content": "eness. This has motivated our development of synchronous stochastic optimization with backup", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 542, + 351, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 351, + 558 + ], + "score": 1.0, + "content": "workers, which we show to be a viable and scalable strategy.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32, + "bbox_fs": [ + 105, + 500, + 506, + 558 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 560, + 505, + 627 + ], + "lines": [ + { + "bbox": [ + 105, + 560, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 505, + 573 + ], + "score": 1.0, + "content": "We are currently experimenting with different kinds of datasets, including word-level language mod-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 571, + 505, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 571, + 505, + 585 + ], + "score": 1.0, + "content": "els where parts of the model (the embedding layers) are often very sparse, which involves very", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 582, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 595 + ], + "score": 1.0, + "content": "different communication constraints. We are also working on further improving the performance", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 594, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 106, + 594, + 505, + 605 + ], + "score": 1.0, + "content": "of synchronous training like combining gradients from multiple workers sharing the same machine", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "score": 1.0, + "content": "before sending them to the parameter servers to reduce the communication overhead. An alternative", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 615, + 380, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 380, + 627 + ], + "score": 1.0, + "content": "of using time-outs instead of backup workers is also being explored.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 37.5, + "bbox_fs": [ + 105, + 560, + 505, + 627 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 644, + 175, + 655 + ], + "lines": [ + { + "bbox": [ + 106, + 643, + 176, + 656 + ], + "spans": [ + { + "bbox": [ + 106, + 643, + 176, + 656 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 108, + 661, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 661, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 106, + 661, + 505, + 673 + ], + "score": 1.0, + "content": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado,", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 670, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 115, + 670, + 505, + 685 + ], + "score": 1.0, + "content": "Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 114, + 679, + 506, + 695 + ], + "spans": [ + { + "bbox": [ + 114, + 679, + 506, + 695 + ], + "score": 1.0, + "content": "Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 691, + 505, + 703 + ], + "spans": [ + { + "bbox": [ + 115, + 691, + 505, + 703 + ], + "score": 1.0, + "content": "Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit ´", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 115, + 699, + 506, + 715 + ], + "spans": [ + { + "bbox": [ + 115, + 699, + 506, + 715 + ], + "score": 1.0, + "content": "Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, ´", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 116, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 116, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow:", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 115, + 721, + 489, + 733 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 489, + 733 + ], + "score": 1.0, + "content": "Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow.org/.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 45, + "bbox_fs": [ + 106, + 661, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 83, + 503, + 104 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Jianmin Chen, Rajat Monga, Samy Bengio, and Rafal Jozefowicz. Revisiting distributed synchronous sgd.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 116, + 93, + 262, + 104 + ], + "spans": [ + { + "bbox": [ + 116, + 93, + 262, + 104 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1604.00981, 2016.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 108, + 111, + 503, + 142 + ], + "lines": [ + { + "bbox": [ + 105, + 110, + 505, + 124 + ], + "spans": [ + { + "bbox": [ + 105, + 110, + 505, + 124 + ], + "score": 1.0, + "content": "T. Chilimbi, Y. Suzue, J. Apacible, and K. Kalyanaraman. Project adam: Building an efficient and scalable deep", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 122, + 505, + 133 + ], + "spans": [ + { + "bbox": [ + 115, + 122, + 505, + 133 + ], + "score": 1.0, + "content": "learning training system. In Proceedings of the 11th USENIX Symposium on Operating Systems Design and", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 131, + 200, + 143 + ], + "spans": [ + { + "bbox": [ + 115, + 131, + 200, + 143 + ], + "score": 1.0, + "content": "Implementation, 2014.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 108, + 149, + 504, + 181 + ], + "lines": [ + { + "bbox": [ + 106, + 149, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 106, + 149, + 505, + 162 + ], + "score": 1.0, + "content": "Dipankar Das, Sasikanth Avancha, Dheevatsa Mudigere, Karthikeyan Vaidynathan, Srinivas Sridharan, Dhiraj", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 159, + 505, + 172 + ], + "spans": [ + { + "bbox": [ + 115, + 159, + 505, + 172 + ], + "score": 1.0, + "content": "Kalamkar, Bharat Kaul, and Pradeep Dubey. Distributed deep learning using synchronous stochastic gradient", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 170, + 295, + 182 + ], + "spans": [ + { + "bbox": [ + 116, + 170, + 295, + 182 + ], + "score": 1.0, + "content": "descent. arXiv preprint arXiv:1602.06709, 2016.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 187, + 504, + 209 + ], + "lines": [ + { + "bbox": [ + 106, + 187, + 506, + 200 + ], + "spans": [ + { + "bbox": [ + 106, + 187, + 506, + 200 + ], + "score": 1.0, + "content": "Christopher M De Sa, Ce Zhang, Kunle Olukotun, and Christopher Re. Taming the wild: A unified analysis of ´", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 198, + 495, + 210 + ], + "spans": [ + { + "bbox": [ + 115, + 198, + 495, + 210 + ], + "score": 1.0, + "content": "hogwild-style algorithms. In Advances in Neural Information Processing Systems, pp. 2674–2682, 2015.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 107, + 216, + 504, + 247 + ], + "lines": [ + { + "bbox": [ + 105, + 216, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 505, + 227 + ], + "score": 1.0, + "content": "J. Dean, G. S. Corrado, R. Monga, K. Chen, M. Devin, Q. V. Le, M. Z. Mao, M. A. Ranzato, A. Senior,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 226, + 506, + 238 + ], + "spans": [ + { + "bbox": [ + 115, + 226, + 506, + 238 + ], + "score": 1.0, + "content": "P. Tucker, K. Yang, and A. Y. Ng. Large scale distributed deep networks. In Advances in Neural Information", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 236, + 237, + 248 + ], + "spans": [ + { + "bbox": [ + 116, + 236, + 237, + 248 + ], + "score": 1.0, + "content": "Processing Systems, NIPS, 2012.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 254, + 503, + 276 + ], + "lines": [ + { + "bbox": [ + 105, + 253, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 505, + 267 + ], + "score": 1.0, + "content": "Jeffrey Dean and Luiz Andr Barroso. The tail at scale. Communications of the ACM, 56:74–80, 2013. URL", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 265, + 500, + 276 + ], + "spans": [ + { + "bbox": [ + 116, + 265, + 500, + 276 + ], + "score": 1.0, + "content": "http://cacm.acm.org/magazines/2013/2/160173-the-tail-at-scale/fulltext.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 105, + 282, + 504, + 304 + ], + "lines": [ + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "score": 1.0, + "content": "John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 293, + 408, + 304 + ], + "spans": [ + { + "bbox": [ + 116, + 293, + 408, + 304 + ], + "score": 1.0, + "content": "optimization. Journal of Machine Learning Research, 12(Jul):2121–2159, 2011.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 104, + 311, + 504, + 333 + ], + "lines": [ + { + "bbox": [ + 106, + 311, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 106, + 311, + 505, + 323 + ], + "score": 1.0, + "content": "John Duchi, Michael I Jordan, and Brendan McMahan. Estimation, optimization, and parallelism when data is", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 321, + 428, + 333 + ], + "spans": [ + { + "bbox": [ + 115, + 321, + 428, + 333 + ], + "score": 1.0, + "content": "sparse. In Advances in Neural Information Processing Systems, pp. 2832–2840, 2013.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 109, + 339, + 504, + 370 + ], + "lines": [ + { + "bbox": [ + 106, + 339, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 505, + 351 + ], + "score": 1.0, + "content": "G. Hinton, L. Deng, D. Yu, G. Dahl, A. Mohamed, N. Jaitly, A. Senior, V. Vanhoucke, P. Nguyen, T. N.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 349, + 505, + 361 + ], + "spans": [ + { + "bbox": [ + 116, + 349, + 505, + 361 + ], + "score": 1.0, + "content": "Sainath, and B. Kingsbury. Deep neural networks for acoustic modeling in speech recognition. IEEE Signal", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 116, + 359, + 259, + 371 + ], + "spans": [ + { + "bbox": [ + 116, + 359, + 259, + 371 + ], + "score": 1.0, + "content": "Processing Magazine, 29:82–97, 2012.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 105, + 378, + 504, + 399 + ], + "lines": [ + { + "bbox": [ + 105, + 377, + 505, + 390 + ], + "spans": [ + { + "bbox": [ + 105, + 377, + 505, + 390 + ], + "score": 1.0, + "content": "S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 388, + 460, + 399 + ], + "spans": [ + { + "bbox": [ + 116, + 388, + 460, + 399 + ], + "score": 1.0, + "content": "shift. In Proceedings of the 32nd International Conference on Machine Learning, ICML, 2015.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 106, + 406, + 504, + 437 + ], + "lines": [ + { + "bbox": [ + 105, + 406, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 505, + 418 + ], + "score": 1.0, + "content": "Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 116, + 416, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 116, + 416, + 505, + 428 + ], + "score": 1.0, + "content": "Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 426, + 208, + 437 + ], + "spans": [ + { + "bbox": [ + 115, + 426, + 208, + 437 + ], + "score": 1.0, + "content": "arXiv:1609.04836, 2016.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 444, + 504, + 466 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 505, + 457 + ], + "score": 1.0, + "content": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 454, + 205, + 465 + ], + "spans": [ + { + "bbox": [ + 115, + 454, + 205, + 465 + ], + "score": 1.0, + "content": "arXiv:1412.6980, 2014.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 104, + 472, + 469, + 484 + ], + "lines": [ + { + "bbox": [ + 105, + 472, + 469, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 469, + 486 + ], + "score": 1.0, + "content": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 105, + 491, + 504, + 512 + ], + "lines": [ + { + "bbox": [ + 105, + 490, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 490, + 505, + 504 + ], + "score": 1.0, + "content": "Remi Leblond, Fabian Pedregosa, and Simon Lacoste-Julien. Asaga: Asynchronous parallel saga. ´ arXiv", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 501, + 240, + 513 + ], + "spans": [ + { + "bbox": [ + 115, + 501, + 240, + 513 + ], + "score": 1.0, + "content": "preprint arXiv:1606.04809, 2016.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5 + }, + { + "type": "text", + "bbox": [ + 107, + 519, + 504, + 551 + ], + "lines": [ + { + "bbox": [ + 105, + 518, + 506, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 506, + 533 + ], + "score": 1.0, + "content": "Mu Li, David G Andersen, Jun Woo Park, Alexander J Smola, Amr Ahmed, Vanja Josifovski, James Long,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 529, + 505, + 541 + ], + "spans": [ + { + "bbox": [ + 116, + 529, + 505, + 541 + ], + "score": 1.0, + "content": "Eugene J Shekita, and Bor-Yiing Su. Scaling distributed machine learning with the parameter server. In 11th", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 117, + 540, + 489, + 552 + ], + "spans": [ + { + "bbox": [ + 117, + 540, + 489, + 552 + ], + "score": 1.0, + "content": "USENIX Symposium on Operating Systems Design and Implementation (OSDI 14), pp. 583–598, 2014.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 106, + 558, + 503, + 589 + ], + "lines": [ + { + "bbox": [ + 106, + 558, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 558, + 505, + 569 + ], + "score": 1.0, + "content": "Horia Mania, Xinghao Pan, Dimitris Papailiopoulos, Benjamin Recht, Kannan Ramchandran, and", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 115, + 567, + 505, + 580 + ], + "spans": [ + { + "bbox": [ + 115, + 567, + 505, + 580 + ], + "score": 1.0, + "content": "Michael I Jordan. Perturbed iterate analysis for asynchronous stochastic optimization. arXiv preprint", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 578, + 209, + 589 + ], + "spans": [ + { + "bbox": [ + 115, + 578, + 209, + 589 + ], + "score": 1.0, + "content": "arXiv:1507.06970, 2015.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36 + }, + { + "type": "text", + "bbox": [ + 105, + 596, + 504, + 617 + ], + "lines": [ + { + "bbox": [ + 106, + 596, + 504, + 608 + ], + "spans": [ + { + "bbox": [ + 106, + 596, + 504, + 608 + ], + "score": 1.0, + "content": "Aaron van den Oord, Nal Kalchbrenner, Oriol Vinyals, Lasse Espeholt, Alex Graves, and Koray Kavukcuoglu.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 606, + 460, + 618 + ], + "spans": [ + { + "bbox": [ + 116, + 606, + 460, + 618 + ], + "score": 1.0, + "content": "Conditional image generation with pixelcnn decoders. arXiv preprint arXiv:1606.05328, 2016.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5 + }, + { + "type": "text", + "bbox": [ + 106, + 624, + 505, + 655 + ], + "lines": [ + { + "bbox": [ + 106, + 624, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 505, + 636 + ], + "score": 1.0, + "content": "Benjamin Recht, Christopher Re, Stephen Wright, and Feng Niu. Hogwild: A lock-free approach to paral-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 115, + 634, + 505, + 646 + ], + "spans": [ + { + "bbox": [ + 115, + 634, + 505, + 646 + ], + "score": 1.0, + "content": "lelizing stochastic gradient descent. In Advances in Neural Information Processing Systems, pp. 693–701,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 643, + 141, + 656 + ], + "spans": [ + { + "bbox": [ + 115, + 643, + 141, + 656 + ], + "score": 1.0, + "content": "2011.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 106, + 663, + 504, + 694 + ], + "lines": [ + { + "bbox": [ + 106, + 662, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 106, + 662, + 505, + 675 + ], + "score": 1.0, + "content": "Sashank J Reddi, Ahmed Hefny, Suvrit Sra, Barnabas Poczos, and Alex J Smola. On variance reduction in", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 672, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 115, + 672, + 505, + 685 + ], + "score": 1.0, + "content": "stochastic gradient descent and its asynchronous variants. In Advances in Neural Information Processing", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 683, + 230, + 694 + ], + "spans": [ + { + "bbox": [ + 115, + 683, + 230, + 694 + ], + "score": 1.0, + "content": "Systems, pp. 2647–2655, 2015.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44 + }, + { + "type": "text", + "bbox": [ + 107, + 701, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 699, + 505, + 714 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 714 + ], + "score": 1.0, + "content": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 115, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 115, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. Imagenet large scale visual", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 115, + 721, + 385, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 385, + 732 + ], + "score": 1.0, + "content": "recognition challenge. In International Journal of Computer Vision, 2015.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2017", + "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": "text", + "bbox": [ + 105, + 83, + 503, + 104 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Jianmin Chen, Rajat Monga, Samy Bengio, and Rafal Jozefowicz. Revisiting distributed synchronous sgd.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 116, + 93, + 262, + 104 + ], + "spans": [ + { + "bbox": [ + 116, + 93, + 262, + 104 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1604.00981, 2016.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 105, + 82, + 505, + 104 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 111, + 503, + 142 + ], + "lines": [ + { + "bbox": [ + 105, + 110, + 505, + 124 + ], + "spans": [ + { + "bbox": [ + 105, + 110, + 505, + 124 + ], + "score": 1.0, + "content": "T. Chilimbi, Y. Suzue, J. Apacible, and K. Kalyanaraman. Project adam: Building an efficient and scalable deep", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 122, + 505, + 133 + ], + "spans": [ + { + "bbox": [ + 115, + 122, + 505, + 133 + ], + "score": 1.0, + "content": "learning training system. In Proceedings of the 11th USENIX Symposium on Operating Systems Design and", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 131, + 200, + 143 + ], + "spans": [ + { + "bbox": [ + 115, + 131, + 200, + 143 + ], + "score": 1.0, + "content": "Implementation, 2014.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3, + "bbox_fs": [ + 105, + 110, + 505, + 143 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 149, + 504, + 181 + ], + "lines": [ + { + "bbox": [ + 106, + 149, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 106, + 149, + 505, + 162 + ], + "score": 1.0, + "content": "Dipankar Das, Sasikanth Avancha, Dheevatsa Mudigere, Karthikeyan Vaidynathan, Srinivas Sridharan, Dhiraj", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 159, + 505, + 172 + ], + "spans": [ + { + "bbox": [ + 115, + 159, + 505, + 172 + ], + "score": 1.0, + "content": "Kalamkar, Bharat Kaul, and Pradeep Dubey. Distributed deep learning using synchronous stochastic gradient", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 170, + 295, + 182 + ], + "spans": [ + { + "bbox": [ + 116, + 170, + 295, + 182 + ], + "score": 1.0, + "content": "descent. arXiv preprint arXiv:1602.06709, 2016.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6, + "bbox_fs": [ + 106, + 149, + 505, + 182 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 187, + 504, + 209 + ], + "lines": [ + { + "bbox": [ + 106, + 187, + 506, + 200 + ], + "spans": [ + { + "bbox": [ + 106, + 187, + 506, + 200 + ], + "score": 1.0, + "content": "Christopher M De Sa, Ce Zhang, Kunle Olukotun, and Christopher Re. Taming the wild: A unified analysis of ´", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 198, + 495, + 210 + ], + "spans": [ + { + "bbox": [ + 115, + 198, + 495, + 210 + ], + "score": 1.0, + "content": "hogwild-style algorithms. In Advances in Neural Information Processing Systems, pp. 2674–2682, 2015.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5, + "bbox_fs": [ + 106, + 187, + 506, + 210 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 216, + 504, + 247 + ], + "lines": [ + { + "bbox": [ + 105, + 216, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 505, + 227 + ], + "score": 1.0, + "content": "J. Dean, G. S. Corrado, R. Monga, K. Chen, M. Devin, Q. V. Le, M. Z. Mao, M. A. Ranzato, A. Senior,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 226, + 506, + 238 + ], + "spans": [ + { + "bbox": [ + 115, + 226, + 506, + 238 + ], + "score": 1.0, + "content": "P. Tucker, K. Yang, and A. Y. Ng. Large scale distributed deep networks. In Advances in Neural Information", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 236, + 237, + 248 + ], + "spans": [ + { + "bbox": [ + 116, + 236, + 237, + 248 + ], + "score": 1.0, + "content": "Processing Systems, NIPS, 2012.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11, + "bbox_fs": [ + 105, + 216, + 506, + 248 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 254, + 503, + 276 + ], + "lines": [ + { + "bbox": [ + 105, + 253, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 505, + 267 + ], + "score": 1.0, + "content": "Jeffrey Dean and Luiz Andr Barroso. The tail at scale. Communications of the ACM, 56:74–80, 2013. URL", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 265, + 500, + 276 + ], + "spans": [ + { + "bbox": [ + 116, + 265, + 500, + 276 + ], + "score": 1.0, + "content": "http://cacm.acm.org/magazines/2013/2/160173-the-tail-at-scale/fulltext.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5, + "bbox_fs": [ + 105, + 253, + 505, + 276 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 282, + 504, + 304 + ], + "lines": [ + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "score": 1.0, + "content": "John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 293, + 408, + 304 + ], + "spans": [ + { + "bbox": [ + 116, + 293, + 408, + 304 + ], + "score": 1.0, + "content": "optimization. Journal of Machine Learning Research, 12(Jul):2121–2159, 2011.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 282, + 505, + 304 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 311, + 504, + 333 + ], + "lines": [ + { + "bbox": [ + 106, + 311, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 106, + 311, + 505, + 323 + ], + "score": 1.0, + "content": "John Duchi, Michael I Jordan, and Brendan McMahan. Estimation, optimization, and parallelism when data is", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 321, + 428, + 333 + ], + "spans": [ + { + "bbox": [ + 115, + 321, + 428, + 333 + ], + "score": 1.0, + "content": "sparse. In Advances in Neural Information Processing Systems, pp. 2832–2840, 2013.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5, + "bbox_fs": [ + 106, + 311, + 505, + 333 + ] + }, + { + "type": "text", + "bbox": [ + 109, + 339, + 504, + 370 + ], + "lines": [ + { + "bbox": [ + 106, + 339, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 505, + 351 + ], + "score": 1.0, + "content": "G. Hinton, L. Deng, D. Yu, G. Dahl, A. Mohamed, N. Jaitly, A. Senior, V. Vanhoucke, P. Nguyen, T. N.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 349, + 505, + 361 + ], + "spans": [ + { + "bbox": [ + 116, + 349, + 505, + 361 + ], + "score": 1.0, + "content": "Sainath, and B. Kingsbury. Deep neural networks for acoustic modeling in speech recognition. IEEE Signal", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 116, + 359, + 259, + 371 + ], + "spans": [ + { + "bbox": [ + 116, + 359, + 259, + 371 + ], + "score": 1.0, + "content": "Processing Magazine, 29:82–97, 2012.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20, + "bbox_fs": [ + 106, + 339, + 505, + 371 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 378, + 504, + 399 + ], + "lines": [ + { + "bbox": [ + 105, + 377, + 505, + 390 + ], + "spans": [ + { + "bbox": [ + 105, + 377, + 505, + 390 + ], + "score": 1.0, + "content": "S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 388, + 460, + 399 + ], + "spans": [ + { + "bbox": [ + 116, + 388, + 460, + 399 + ], + "score": 1.0, + "content": "shift. In Proceedings of the 32nd International Conference on Machine Learning, ICML, 2015.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 377, + 505, + 399 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 406, + 504, + 437 + ], + "lines": [ + { + "bbox": [ + 105, + 406, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 505, + 418 + ], + "score": 1.0, + "content": "Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 116, + 416, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 116, + 416, + 505, + 428 + ], + "score": 1.0, + "content": "Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 426, + 208, + 437 + ], + "spans": [ + { + "bbox": [ + 115, + 426, + 208, + 437 + ], + "score": 1.0, + "content": "arXiv:1609.04836, 2016.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 406, + 505, + 437 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 444, + 504, + 466 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 505, + 457 + ], + "score": 1.0, + "content": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 454, + 205, + 465 + ], + "spans": [ + { + "bbox": [ + 115, + 454, + 205, + 465 + ], + "score": 1.0, + "content": "arXiv:1412.6980, 2014.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 442, + 505, + 465 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 472, + 469, + 484 + ], + "lines": [ + { + "bbox": [ + 105, + 472, + 469, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 469, + 486 + ], + "score": 1.0, + "content": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29, + "bbox_fs": [ + 105, + 472, + 469, + 486 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 491, + 504, + 512 + ], + "lines": [ + { + "bbox": [ + 105, + 490, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 490, + 505, + 504 + ], + "score": 1.0, + "content": "Remi Leblond, Fabian Pedregosa, and Simon Lacoste-Julien. Asaga: Asynchronous parallel saga. ´ arXiv", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 501, + 240, + 513 + ], + "spans": [ + { + "bbox": [ + 115, + 501, + 240, + 513 + ], + "score": 1.0, + "content": "preprint arXiv:1606.04809, 2016.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 490, + 505, + 513 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 519, + 504, + 551 + ], + "lines": [ + { + "bbox": [ + 105, + 518, + 506, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 506, + 533 + ], + "score": 1.0, + "content": "Mu Li, David G Andersen, Jun Woo Park, Alexander J Smola, Amr Ahmed, Vanja Josifovski, James Long,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 529, + 505, + 541 + ], + "spans": [ + { + "bbox": [ + 116, + 529, + 505, + 541 + ], + "score": 1.0, + "content": "Eugene J Shekita, and Bor-Yiing Su. Scaling distributed machine learning with the parameter server. In 11th", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 117, + 540, + 489, + 552 + ], + "spans": [ + { + "bbox": [ + 117, + 540, + 489, + 552 + ], + "score": 1.0, + "content": "USENIX Symposium on Operating Systems Design and Implementation (OSDI 14), pp. 583–598, 2014.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33, + "bbox_fs": [ + 105, + 518, + 506, + 552 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 558, + 503, + 589 + ], + "lines": [ + { + "bbox": [ + 106, + 558, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 558, + 505, + 569 + ], + "score": 1.0, + "content": "Horia Mania, Xinghao Pan, Dimitris Papailiopoulos, Benjamin Recht, Kannan Ramchandran, and", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 115, + 567, + 505, + 580 + ], + "spans": [ + { + "bbox": [ + 115, + 567, + 505, + 580 + ], + "score": 1.0, + "content": "Michael I Jordan. Perturbed iterate analysis for asynchronous stochastic optimization. arXiv preprint", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 578, + 209, + 589 + ], + "spans": [ + { + "bbox": [ + 115, + 578, + 209, + 589 + ], + "score": 1.0, + "content": "arXiv:1507.06970, 2015.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36, + "bbox_fs": [ + 106, + 558, + 505, + 589 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 596, + 504, + 617 + ], + "lines": [ + { + "bbox": [ + 106, + 596, + 504, + 608 + ], + "spans": [ + { + "bbox": [ + 106, + 596, + 504, + 608 + ], + "score": 1.0, + "content": "Aaron van den Oord, Nal Kalchbrenner, Oriol Vinyals, Lasse Espeholt, Alex Graves, and Koray Kavukcuoglu.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 606, + 460, + 618 + ], + "spans": [ + { + "bbox": [ + 116, + 606, + 460, + 618 + ], + "score": 1.0, + "content": "Conditional image generation with pixelcnn decoders. arXiv preprint arXiv:1606.05328, 2016.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5, + "bbox_fs": [ + 106, + 596, + 504, + 618 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 624, + 505, + 655 + ], + "lines": [ + { + "bbox": [ + 106, + 624, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 505, + 636 + ], + "score": 1.0, + "content": "Benjamin Recht, Christopher Re, Stephen Wright, and Feng Niu. Hogwild: A lock-free approach to paral-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 115, + 634, + 505, + 646 + ], + "spans": [ + { + "bbox": [ + 115, + 634, + 505, + 646 + ], + "score": 1.0, + "content": "lelizing stochastic gradient descent. In Advances in Neural Information Processing Systems, pp. 693–701,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 643, + 141, + 656 + ], + "spans": [ + { + "bbox": [ + 115, + 643, + 141, + 656 + ], + "score": 1.0, + "content": "2011.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41, + "bbox_fs": [ + 106, + 624, + 505, + 656 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 663, + 504, + 694 + ], + "lines": [ + { + "bbox": [ + 106, + 662, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 106, + 662, + 505, + 675 + ], + "score": 1.0, + "content": "Sashank J Reddi, Ahmed Hefny, Suvrit Sra, Barnabas Poczos, and Alex J Smola. On variance reduction in", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 672, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 115, + 672, + 505, + 685 + ], + "score": 1.0, + "content": "stochastic gradient descent and its asynchronous variants. In Advances in Neural Information Processing", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 683, + 230, + 694 + ], + "spans": [ + { + "bbox": [ + 115, + 683, + 230, + 694 + ], + "score": 1.0, + "content": "Systems, pp. 2647–2655, 2015.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44, + "bbox_fs": [ + 106, + 662, + 505, + 694 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 701, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 699, + 505, + 714 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 714 + ], + "score": 1.0, + "content": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 115, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 115, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. Imagenet large scale visual", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 115, + 721, + 385, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 385, + 732 + ], + "score": 1.0, + "content": "recognition challenge. In International Journal of Computer Vision, 2015.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47, + "bbox_fs": [ + 105, + 699, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 104, + 81, + 506, + 320 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "C. Szegedy, V. Vanhoucke, S. Ioffe, J. Shlens, and Z. Wojna. Rethinking the inception architecture for computer", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 116, + 94, + 246, + 105 + ], + "spans": [ + { + "bbox": [ + 116, + 94, + 246, + 105 + ], + "score": 1.0, + "content": "vision. In ArXiv 1512.00567, 2016.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 111, + 505, + 124 + ], + "spans": [ + { + "bbox": [ + 106, + 111, + 505, + 124 + ], + "score": 1.0, + "content": "Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 121, + 424, + 134 + ], + "spans": [ + { + "bbox": [ + 115, + 121, + 424, + 134 + ], + "score": 1.0, + "content": "recent magnitude. COURSERA: Neural Networks for Machine Learning, 4(2), 2012.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 139, + 506, + 152 + ], + "spans": [ + { + "bbox": [ + 105, + 139, + 506, + 152 + ], + "score": 1.0, + "content": "Pijika Watcharapichat, Victoria Lopez Morales, Raul Castro Fernandez, and Peter Pietzuch. Ako: Decentralised", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 149, + 506, + 162 + ], + "spans": [ + { + "bbox": [ + 115, + 149, + 506, + 162 + ], + "score": 1.0, + "content": "deep learning with partial gradient exchange. In Proceedings of the Seventh ACM Symposium on Cloud", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 116, + 159, + 249, + 172 + ], + "spans": [ + { + "bbox": [ + 116, + 159, + 249, + 172 + ], + "score": 1.0, + "content": "Computing, pp. 84–97. ACM, 2016.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 177, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 505, + 189 + ], + "score": 1.0, + "content": "Eric P Xing, Qirong Ho, Wei Dai, Jin Kyu Kim, Jinliang Wei, Seunghak Lee, Xun Zheng, Pengtao Xie, Abhi-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 187, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 115, + 187, + 505, + 200 + ], + "score": 1.0, + "content": "manu Kumar, and Yaoliang Yu. Petuum: A new platform for distributed machine learning on big data. IEEE", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 197, + 280, + 210 + ], + "spans": [ + { + "bbox": [ + 115, + 197, + 280, + 210 + ], + "score": 1.0, + "content": "Transactions on Big Data, 1(2):49–67, 2015.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 214, + 505, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 505, + 228 + ], + "score": 1.0, + "content": "Sixin Zhang, Anna E Choromanska, and Yann LeCun. Deep learning with elastic averaging sgd. In Advances", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 224, + 348, + 238 + ], + "spans": [ + { + "bbox": [ + 115, + 224, + 348, + 238 + ], + "score": 1.0, + "content": "in Neural Information Processing Systems, pp. 685–693, 2015a.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 241, + 504, + 256 + ], + "spans": [ + { + "bbox": [ + 106, + 241, + 504, + 256 + ], + "score": 1.0, + "content": "Wei Zhang, Suyog Gupta, Xiangru Lian, and Ji Liu. Staleness-aware async-sgd for distributed deep learning.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 253, + 267, + 265 + ], + "spans": [ + { + "bbox": [ + 115, + 253, + 267, + 265 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1511.05950, 2015b.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 270, + 505, + 283 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 505, + 283 + ], + "score": 1.0, + "content": "Yuchen Zhang and Michael I Jordan. Splash: User-friendly programming interface for parallelizing stochastic", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 116, + 281, + 306, + 293 + ], + "spans": [ + { + "bbox": [ + 116, + 281, + 306, + 293 + ], + "score": 1.0, + "content": "algorithms. arXiv preprint arXiv:1506.07552, 2015.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 298, + 506, + 311 + ], + "spans": [ + { + "bbox": [ + 106, + 298, + 506, + 311 + ], + "score": 1.0, + "content": "Martin Zinkevich, Markus Weimer, Lihong Li, and Alex J Smola. Parallelized stochastic gradient descent. In", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 115, + 309, + 386, + 321 + ], + "spans": [ + { + "bbox": [ + 115, + 309, + 386, + 321 + ], + "score": 1.0, + "content": "Advances in neural information processing systems, pp. 2595–2603, 2010.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 8.5 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 765 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 14 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 104, + 81, + 506, + 320 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "C. Szegedy, V. Vanhoucke, S. Ioffe, J. Shlens, and Z. Wojna. Rethinking the inception architecture for computer", + "type": "text" + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 94, + 246, + 105 + ], + "spans": [ + { + "bbox": [ + 116, + 94, + 246, + 105 + ], + "score": 1.0, + "content": "vision. In ArXiv 1512.00567, 2016.", + "type": "text" + } + ], + "index": 1, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 111, + 505, + 124 + ], + "spans": [ + { + "bbox": [ + 106, + 111, + 505, + 124 + ], + "score": 1.0, + "content": "Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its", + "type": "text" + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 121, + 424, + 134 + ], + "spans": [ + { + "bbox": [ + 115, + 121, + 424, + 134 + ], + "score": 1.0, + "content": "recent magnitude. COURSERA: Neural Networks for Machine Learning, 4(2), 2012.", + "type": "text" + } + ], + "index": 3, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 139, + 506, + 152 + ], + "spans": [ + { + "bbox": [ + 105, + 139, + 506, + 152 + ], + "score": 1.0, + "content": "Pijika Watcharapichat, Victoria Lopez Morales, Raul Castro Fernandez, and Peter Pietzuch. Ako: Decentralised", + "type": "text" + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 149, + 506, + 162 + ], + "spans": [ + { + "bbox": [ + 115, + 149, + 506, + 162 + ], + "score": 1.0, + "content": "deep learning with partial gradient exchange. In Proceedings of the Seventh ACM Symposium on Cloud", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 116, + 159, + 249, + 172 + ], + "spans": [ + { + "bbox": [ + 116, + 159, + 249, + 172 + ], + "score": 1.0, + "content": "Computing, pp. 84–97. ACM, 2016.", + "type": "text" + } + ], + "index": 6, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 177, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 505, + 189 + ], + "score": 1.0, + "content": "Eric P Xing, Qirong Ho, Wei Dai, Jin Kyu Kim, Jinliang Wei, Seunghak Lee, Xun Zheng, Pengtao Xie, Abhi-", + "type": "text" + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 187, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 115, + 187, + 505, + 200 + ], + "score": 1.0, + "content": "manu Kumar, and Yaoliang Yu. Petuum: A new platform for distributed machine learning on big data. IEEE", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 197, + 280, + 210 + ], + "spans": [ + { + "bbox": [ + 115, + 197, + 280, + 210 + ], + "score": 1.0, + "content": "Transactions on Big Data, 1(2):49–67, 2015.", + "type": "text" + } + ], + "index": 9, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 214, + 505, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 505, + 228 + ], + "score": 1.0, + "content": "Sixin Zhang, Anna E Choromanska, and Yann LeCun. Deep learning with elastic averaging sgd. In Advances", + "type": "text" + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 224, + 348, + 238 + ], + "spans": [ + { + "bbox": [ + 115, + 224, + 348, + 238 + ], + "score": 1.0, + "content": "in Neural Information Processing Systems, pp. 685–693, 2015a.", + "type": "text" + } + ], + "index": 11, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 241, + 504, + 256 + ], + "spans": [ + { + "bbox": [ + 106, + 241, + 504, + 256 + ], + "score": 1.0, + "content": "Wei Zhang, Suyog Gupta, Xiangru Lian, and Ji Liu. Staleness-aware async-sgd for distributed deep learning.", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 253, + 267, + 265 + ], + "spans": [ + { + "bbox": [ + 115, + 253, + 267, + 265 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1511.05950, 2015b.", + "type": "text" + } + ], + "index": 13, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 270, + 505, + 283 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 505, + 283 + ], + "score": 1.0, + "content": "Yuchen Zhang and Michael I Jordan. Splash: User-friendly programming interface for parallelizing stochastic", + "type": "text" + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 281, + 306, + 293 + ], + "spans": [ + { + "bbox": [ + 116, + 281, + 306, + 293 + ], + "score": 1.0, + "content": "algorithms. arXiv preprint arXiv:1506.07552, 2015.", + "type": "text" + } + ], + "index": 15, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 298, + 506, + 311 + ], + "spans": [ + { + "bbox": [ + 106, + 298, + 506, + 311 + ], + "score": 1.0, + "content": "Martin Zinkevich, Markus Weimer, Lihong Li, and Alex J Smola. Parallelized stochastic gradient descent. In", + "type": "text" + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 309, + 386, + 321 + ], + "spans": [ + { + "bbox": [ + 115, + 309, + 386, + 321 + ], + "score": 1.0, + "content": "Advances in neural information processing systems, pp. 2595–2603, 2010.", + "type": "text" + } + ], + "index": 17, + "is_list_end_line": true + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 82, + 506, + 321 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 319, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 320, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 320, + 95 + ], + "score": 1.0, + "content": "A DETAILS OF MODELS AND TRAINING", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 108, + 105, + 252, + 118 + ], + "lines": [ + { + "bbox": [ + 106, + 105, + 253, + 119 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 253, + 119 + ], + "score": 1.0, + "content": "A.1 MNIST CNN, SECTION 2.1", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 127, + 505, + 182 + ], + "lines": [ + { + "bbox": [ + 106, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 106, + 126, + 368, + 139 + ], + "score": 1.0, + "content": "The model used in our experiments is a 4-layer CNN that have", + "type": "text" + }, + { + "bbox": [ + 369, + 127, + 385, + 137 + ], + "score": 0.45, + "content": "3 { \\tt X } 3", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 126, + 505, + 139 + ], + "score": 1.0, + "content": "filters with max-pooling and", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 137, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 505, + 150 + ], + "score": 1.0, + "content": "weight normalization in every layer. We trained the model with SGD for 25 epochs and evaluated", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 147, + 506, + 163 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 299, + 163 + ], + "score": 1.0, + "content": "performance on the exponential moving average", + "type": "text" + }, + { + "bbox": [ + 300, + 147, + 306, + 159 + ], + "score": 0.8, + "content": "\\bar { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 148, + 391, + 163 + ], + "score": 1.0, + "content": "using a decay rate of", + "type": "text" + }, + { + "bbox": [ + 391, + 149, + 439, + 159 + ], + "score": 0.87, + "content": "\\alpha = 0 . 9 9 9 9", + "type": "inline_equation" + }, + { + "bbox": [ + 440, + 148, + 506, + 163 + ], + "score": 1.0, + "content": ". Initial learning", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 158, + 505, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 158, + 505, + 174 + ], + "score": 1.0, + "content": "rate was set to be 0.1 and linearly annealed to 0 in the last 10 epochs. We also used small image", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 170, + 318, + 184 + ], + "spans": [ + { + "bbox": [ + 105, + 170, + 318, + 184 + ], + "score": 1.0, + "content": "rotations and zooms as a data augmentation scheme.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4 + }, + { + "type": "title", + "bbox": [ + 108, + 195, + 240, + 207 + ], + "lines": [ + { + "bbox": [ + 106, + 195, + 241, + 208 + ], + "spans": [ + { + "bbox": [ + 106, + 195, + 241, + 208 + ], + "score": 1.0, + "content": "A.2 INCEPTION, SECTION 3.1", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 108, + 216, + 504, + 249 + ], + "lines": [ + { + "bbox": [ + 105, + 215, + 505, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 215, + 505, + 228 + ], + "score": 1.0, + "content": "For our straggler experiments, we trained the Inception (Szegedy et al., 2016) model on the Im-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 226, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 226, + 506, + 239 + ], + "score": 1.0, + "content": "ageNet Challenge dataset (Russakovsky et al., 2015). 10 parameter servers were used, and each", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 238, + 264, + 250 + ], + "spans": [ + { + "bbox": [ + 106, + 238, + 264, + 250 + ], + "score": 1.0, + "content": "worker was equipped with a k40 GPU.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 107, + 254, + 505, + 300 + ], + "lines": [ + { + "bbox": [ + 106, + 255, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 106, + 255, + 505, + 267 + ], + "score": 1.0, + "content": "The underlying optimizer was RMSProp with momentum, with decay of 0.9 and momentum of 0.9.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 264, + 506, + 278 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 171, + 278 + ], + "score": 1.0, + "content": "Mini-batch size", + "type": "text" + }, + { + "bbox": [ + 172, + 266, + 205, + 276 + ], + "score": 0.9, + "content": "B = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 264, + 332, + 278 + ], + "score": 1.0, + "content": "was used. Initial learning rates", + "type": "text" + }, + { + "bbox": [ + 332, + 268, + 343, + 277 + ], + "score": 0.86, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 344, + 264, + 390, + 278 + ], + "score": 1.0, + "content": "were set at", + "type": "text" + }, + { + "bbox": [ + 390, + 266, + 423, + 276 + ], + "score": 0.87, + "content": "0 . 0 4 5 N", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 264, + 506, + 278 + ], + "score": 1.0, + "content": ", which we found to", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 277, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 277, + 505, + 289 + ], + "score": 1.0, + "content": "provide good test precisions for Inception. Learning rates were also exponentially decreased with", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 287, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 149, + 301 + ], + "score": 1.0, + "content": "decay rate", + "type": "text" + }, + { + "bbox": [ + 149, + 289, + 188, + 300 + ], + "score": 0.9, + "content": "\\beta = 0 . 9 4", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 287, + 199, + 301 + ], + "score": 1.0, + "content": "as", + "type": "text" + }, + { + "bbox": [ + 200, + 288, + 246, + 300 + ], + "score": 0.92, + "content": "\\gamma _ { 0 } \\beta ^ { t N / ( 2 T ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 287, + 277, + 301 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 277, + 289, + 326, + 301 + ], + "score": 0.93, + "content": "T = | { \\mathcal { X } } | / B", + "type": "inline_equation" + }, + { + "bbox": [ + 326, + 287, + 505, + 301 + ], + "score": 1.0, + "content": "is the number of mini-batches in the dataset.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 106, + 305, + 455, + 317 + ], + "lines": [ + { + "bbox": [ + 105, + 304, + 456, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 372, + 319 + ], + "score": 1.0, + "content": "Test precisions were evaluated on the exponential moving average", + "type": "text" + }, + { + "bbox": [ + 372, + 305, + 379, + 316 + ], + "score": 0.79, + "content": "\\bar { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 304, + 403, + 319 + ], + "score": 1.0, + "content": "using", + "type": "text" + }, + { + "bbox": [ + 404, + 306, + 452, + 316 + ], + "score": 0.86, + "content": "\\alpha = 0 . 9 9 9 9", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 304, + 456, + 319 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "title", + "bbox": [ + 108, + 330, + 241, + 342 + ], + "lines": [ + { + "bbox": [ + 106, + 329, + 243, + 344 + ], + "spans": [ + { + "bbox": [ + 106, + 329, + 243, + 344 + ], + "score": 1.0, + "content": "A.3 INCEPTION, SECTION 4.2", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 351, + 505, + 395 + ], + "lines": [ + { + "bbox": [ + 106, + 352, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 106, + 352, + 505, + 363 + ], + "score": 1.0, + "content": "For experiments comparing Async-Opt and Sync-Opt on the Inception model in Section 4.2, each", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 362, + 506, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 277, + 375 + ], + "score": 1.0, + "content": "worker is equipped with a k40 GPU. For", + "type": "text" + }, + { + "bbox": [ + 277, + 362, + 332, + 373 + ], + "score": 0.91, + "content": "N + b = 5 3", + "type": "inline_equation" + }, + { + "bbox": [ + 332, + 362, + 506, + 375 + ], + "score": 1.0, + "content": "workers, 17 parameter servers were used;", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 372, + 506, + 386 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 121, + 386 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 121, + 374, + 179, + 384 + ], + "score": 0.91, + "content": "N + b = 1 0 6", + "type": "inline_equation" + }, + { + "bbox": [ + 179, + 372, + 506, + 386 + ], + "score": 1.0, + "content": "workers, we used 27 parameter servers; and 37 parameter servers were used for", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 107, + 384, + 165, + 396 + ], + "spans": [ + { + "bbox": [ + 107, + 385, + 161, + 395 + ], + "score": 0.88, + "content": "N + b = 2 1 2", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 384, + 165, + 396 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 18.5 + }, + { + "type": "text", + "bbox": [ + 107, + 401, + 505, + 467 + ], + "lines": [ + { + "bbox": [ + 105, + 401, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 505, + 414 + ], + "score": 1.0, + "content": "In the asynchronous training mode, gradient clipping is also needed for stabilization, which requires", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 413, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 505, + 424 + ], + "score": 1.0, + "content": "each worker to collect the gradient across all layers of the deep model, compute the global norm", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 107, + 423, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 107, + 423, + 127, + 435 + ], + "score": 0.9, + "content": "| | G | |", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 423, + 505, + 436 + ], + "score": 1.0, + "content": "and then clip all gradient accordingly. However, synchronization turns out to be very stable so", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 433, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 506, + 447 + ], + "score": 1.0, + "content": "gradient clipping is no longer needed, which means that we can pipeline the update of parameters", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 444, + 505, + 458 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 505, + 458 + ], + "score": 1.0, + "content": "in different layers: the gradient of top layers’ parameters can be sent to parameter servers while", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 456, + 326, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 326, + 469 + ], + "score": 1.0, + "content": "concurrently computing gradients for the lower layers.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 107, + 472, + 505, + 553 + ], + "lines": [ + { + "bbox": [ + 106, + 473, + 505, + 485 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 505, + 485 + ], + "score": 1.0, + "content": "The underlying optimizer is RMSProp with momentum, with decay of 0.9 and momentum of 0.9.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 483, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 172, + 497 + ], + "score": 1.0, + "content": "Mini-batch size", + "type": "text" + }, + { + "bbox": [ + 173, + 484, + 208, + 494 + ], + "score": 0.89, + "content": "B = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 483, + 339, + 497 + ], + "score": 1.0, + "content": "was used. Initial learning rates", + "type": "text" + }, + { + "bbox": [ + 339, + 486, + 351, + 496 + ], + "score": 0.85, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 483, + 505, + 497 + ], + "score": 1.0, + "content": "for Async-Opt were set to 0.045; for", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 494, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 356, + 507 + ], + "score": 1.0, + "content": "Sync-Opt, we found as a rule-of-thumb that a learning rate of", + "type": "text" + }, + { + "bbox": [ + 357, + 495, + 390, + 505 + ], + "score": 0.86, + "content": "0 . 0 4 5 N", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 494, + 505, + 507 + ], + "score": 1.0, + "content": "worked well for this model.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 504, + 505, + 521 + ], + "spans": [ + { + "bbox": [ + 104, + 504, + 365, + 521 + ], + "score": 1.0, + "content": "Learning rates were then exponentially decayed with decay rate", + "type": "text" + }, + { + "bbox": [ + 365, + 507, + 405, + 518 + ], + "score": 0.9, + "content": "\\beta = 0 . 9 4", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 504, + 417, + 521 + ], + "score": 1.0, + "content": "as", + "type": "text" + }, + { + "bbox": [ + 417, + 506, + 457, + 519 + ], + "score": 0.93, + "content": "\\gamma _ { 0 } \\beta ^ { t / ( 2 T ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 504, + 505, + 521 + ], + "score": 1.0, + "content": "for Async-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 517, + 506, + 531 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 152, + 531 + ], + "score": 1.0, + "content": "Opt, where", + "type": "text" + }, + { + "bbox": [ + 153, + 518, + 201, + 530 + ], + "score": 0.93, + "content": "T = | { \\mathcal { X } } | / B", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 517, + 506, + 531 + ], + "score": 1.0, + "content": "is the number of mini-batches in the dataset. For Sync-Opt, we learning rates", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 104, + 526, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 104, + 526, + 285, + 545 + ], + "score": 1.0, + "content": "were also exponentially decreased at rate of", + "type": "text" + }, + { + "bbox": [ + 286, + 529, + 332, + 542 + ], + "score": 0.93, + "content": "\\gamma _ { 0 } \\beta ^ { t N / ( 2 T ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 526, + 506, + 545 + ], + "score": 1.0, + "content": ", so that the learning rates after computing", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 540, + 416, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 416, + 555 + ], + "score": 1.0, + "content": "the same number of datapoints are comparable for Async-Opt and Sync-Opt.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 108, + 558, + 454, + 569 + ], + "lines": [ + { + "bbox": [ + 105, + 556, + 452, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 372, + 572 + ], + "score": 1.0, + "content": "Test precisions were evaluated on the exponential moving average", + "type": "text" + }, + { + "bbox": [ + 372, + 557, + 379, + 568 + ], + "score": 0.8, + "content": "\\bar { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 556, + 403, + 572 + ], + "score": 1.0, + "content": "using", + "type": "text" + }, + { + "bbox": [ + 403, + 558, + 452, + 569 + ], + "score": 0.82, + "content": "\\alpha = 0 . 9 9 9 9", + "type": "inline_equation" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "title", + "bbox": [ + 108, + 582, + 243, + 594 + ], + "lines": [ + { + "bbox": [ + 106, + 582, + 244, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 582, + 244, + 595 + ], + "score": 1.0, + "content": "A.4 PIXELCNN, SECTION 4.3", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 603, + 505, + 669 + ], + "lines": [ + { + "bbox": [ + 106, + 602, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 106, + 602, + 505, + 617 + ], + "score": 1.0, + "content": "The PixelCNN (Oord et al., 2016) model was trained on the CIFAR-10 (Krizhevsky & Hinton,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 614, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 614, + 238, + 628 + ], + "score": 1.0, + "content": "2009) dataset. Configurations of", + "type": "text" + }, + { + "bbox": [ + 239, + 615, + 307, + 626 + ], + "score": 0.86, + "content": "N + b = 1 , 8 , 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 614, + 390, + 628 + ], + "score": 1.0, + "content": "workers each with a", + "type": "text" + }, + { + "bbox": [ + 390, + 615, + 407, + 625 + ], + "score": 0.45, + "content": "\\mathbf { k } 8 0", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 614, + 505, + 628 + ], + "score": 1.0, + "content": "GPU, and 10 parameter", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 626, + 505, + 638 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 309, + 638 + ], + "score": 1.0, + "content": "servers were used. For Sync-Opt, we always used", + "type": "text" + }, + { + "bbox": [ + 309, + 626, + 334, + 636 + ], + "score": 0.89, + "content": "b = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 626, + 505, + 638 + ], + "score": 1.0, + "content": "backup worker. The underlying optimizer", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 104, + 634, + 504, + 651 + ], + "spans": [ + { + "bbox": [ + 104, + 634, + 492, + 651 + ], + "score": 1.0, + "content": "is RMSProp with momentum, using decay of 0.95 and momentum of 0.9. Initial learning rates", + "type": "text" + }, + { + "bbox": [ + 493, + 639, + 504, + 648 + ], + "score": 0.82, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 648, + 504, + 659 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 153, + 659 + ], + "score": 1.0, + "content": "were set to", + "type": "text" + }, + { + "bbox": [ + 153, + 648, + 181, + 658 + ], + "score": 0.74, + "content": "1 e - 4", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 648, + 281, + 659 + ], + "score": 1.0, + "content": "and slowly decreased to", + "type": "text" + }, + { + "bbox": [ + 281, + 648, + 310, + 658 + ], + "score": 0.85, + "content": "3 e - 6", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 648, + 475, + 659 + ], + "score": 1.0, + "content": "after 200,000 iterations. Mini-batch size", + "type": "text" + }, + { + "bbox": [ + 475, + 648, + 504, + 658 + ], + "score": 0.88, + "content": "B = 4", + "type": "inline_equation" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 658, + 148, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 148, + 669 + ], + "score": 1.0, + "content": "was used.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 38.5 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 319, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 320, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 320, + 95 + ], + "score": 1.0, + "content": "A DETAILS OF MODELS AND TRAINING", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 108, + 105, + 252, + 118 + ], + "lines": [ + { + "bbox": [ + 106, + 105, + 253, + 119 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 253, + 119 + ], + "score": 1.0, + "content": "A.1 MNIST CNN, SECTION 2.1", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 127, + 505, + 182 + ], + "lines": [ + { + "bbox": [ + 106, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 106, + 126, + 368, + 139 + ], + "score": 1.0, + "content": "The model used in our experiments is a 4-layer CNN that have", + "type": "text" + }, + { + "bbox": [ + 369, + 127, + 385, + 137 + ], + "score": 0.45, + "content": "3 { \\tt X } 3", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 126, + 505, + 139 + ], + "score": 1.0, + "content": "filters with max-pooling and", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 137, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 505, + 150 + ], + "score": 1.0, + "content": "weight normalization in every layer. We trained the model with SGD for 25 epochs and evaluated", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 147, + 506, + 163 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 299, + 163 + ], + "score": 1.0, + "content": "performance on the exponential moving average", + "type": "text" + }, + { + "bbox": [ + 300, + 147, + 306, + 159 + ], + "score": 0.8, + "content": "\\bar { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 148, + 391, + 163 + ], + "score": 1.0, + "content": "using a decay rate of", + "type": "text" + }, + { + "bbox": [ + 391, + 149, + 439, + 159 + ], + "score": 0.87, + "content": "\\alpha = 0 . 9 9 9 9", + "type": "inline_equation" + }, + { + "bbox": [ + 440, + 148, + 506, + 163 + ], + "score": 1.0, + "content": ". Initial learning", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 158, + 505, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 158, + 505, + 174 + ], + "score": 1.0, + "content": "rate was set to be 0.1 and linearly annealed to 0 in the last 10 epochs. We also used small image", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 170, + 318, + 184 + ], + "spans": [ + { + "bbox": [ + 105, + 170, + 318, + 184 + ], + "score": 1.0, + "content": "rotations and zooms as a data augmentation scheme.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4, + "bbox_fs": [ + 105, + 126, + 506, + 184 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 195, + 240, + 207 + ], + "lines": [ + { + "bbox": [ + 106, + 195, + 241, + 208 + ], + "spans": [ + { + "bbox": [ + 106, + 195, + 241, + 208 + ], + "score": 1.0, + "content": "A.2 INCEPTION, SECTION 3.1", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 108, + 216, + 504, + 249 + ], + "lines": [ + { + "bbox": [ + 105, + 215, + 505, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 215, + 505, + 228 + ], + "score": 1.0, + "content": "For our straggler experiments, we trained the Inception (Szegedy et al., 2016) model on the Im-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 226, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 226, + 506, + 239 + ], + "score": 1.0, + "content": "ageNet Challenge dataset (Russakovsky et al., 2015). 10 parameter servers were used, and each", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 238, + 264, + 250 + ], + "spans": [ + { + "bbox": [ + 106, + 238, + 264, + 250 + ], + "score": 1.0, + "content": "worker was equipped with a k40 GPU.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9, + "bbox_fs": [ + 105, + 215, + 506, + 250 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 254, + 505, + 300 + ], + "lines": [ + { + "bbox": [ + 106, + 255, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 106, + 255, + 505, + 267 + ], + "score": 1.0, + "content": "The underlying optimizer was RMSProp with momentum, with decay of 0.9 and momentum of 0.9.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 264, + 506, + 278 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 171, + 278 + ], + "score": 1.0, + "content": "Mini-batch size", + "type": "text" + }, + { + "bbox": [ + 172, + 266, + 205, + 276 + ], + "score": 0.9, + "content": "B = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 264, + 332, + 278 + ], + "score": 1.0, + "content": "was used. Initial learning rates", + "type": "text" + }, + { + "bbox": [ + 332, + 268, + 343, + 277 + ], + "score": 0.86, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 344, + 264, + 390, + 278 + ], + "score": 1.0, + "content": "were set at", + "type": "text" + }, + { + "bbox": [ + 390, + 266, + 423, + 276 + ], + "score": 0.87, + "content": "0 . 0 4 5 N", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 264, + 506, + 278 + ], + "score": 1.0, + "content": ", which we found to", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 277, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 277, + 505, + 289 + ], + "score": 1.0, + "content": "provide good test precisions for Inception. Learning rates were also exponentially decreased with", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 287, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 149, + 301 + ], + "score": 1.0, + "content": "decay rate", + "type": "text" + }, + { + "bbox": [ + 149, + 289, + 188, + 300 + ], + "score": 0.9, + "content": "\\beta = 0 . 9 4", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 287, + 199, + 301 + ], + "score": 1.0, + "content": "as", + "type": "text" + }, + { + "bbox": [ + 200, + 288, + 246, + 300 + ], + "score": 0.92, + "content": "\\gamma _ { 0 } \\beta ^ { t N / ( 2 T ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 287, + 277, + 301 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 277, + 289, + 326, + 301 + ], + "score": 0.93, + "content": "T = | { \\mathcal { X } } | / B", + "type": "inline_equation" + }, + { + "bbox": [ + 326, + 287, + 505, + 301 + ], + "score": 1.0, + "content": "is the number of mini-batches in the dataset.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12.5, + "bbox_fs": [ + 105, + 255, + 506, + 301 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 305, + 455, + 317 + ], + "lines": [ + { + "bbox": [ + 105, + 304, + 456, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 372, + 319 + ], + "score": 1.0, + "content": "Test precisions were evaluated on the exponential moving average", + "type": "text" + }, + { + "bbox": [ + 372, + 305, + 379, + 316 + ], + "score": 0.79, + "content": "\\bar { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 304, + 403, + 319 + ], + "score": 1.0, + "content": "using", + "type": "text" + }, + { + "bbox": [ + 404, + 306, + 452, + 316 + ], + "score": 0.86, + "content": "\\alpha = 0 . 9 9 9 9", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 304, + 456, + 319 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 304, + 456, + 319 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 330, + 241, + 342 + ], + "lines": [ + { + "bbox": [ + 106, + 329, + 243, + 344 + ], + "spans": [ + { + "bbox": [ + 106, + 329, + 243, + 344 + ], + "score": 1.0, + "content": "A.3 INCEPTION, SECTION 4.2", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 351, + 505, + 395 + ], + "lines": [ + { + "bbox": [ + 106, + 352, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 106, + 352, + 505, + 363 + ], + "score": 1.0, + "content": "For experiments comparing Async-Opt and Sync-Opt on the Inception model in Section 4.2, each", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 362, + 506, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 277, + 375 + ], + "score": 1.0, + "content": "worker is equipped with a k40 GPU. For", + "type": "text" + }, + { + "bbox": [ + 277, + 362, + 332, + 373 + ], + "score": 0.91, + "content": "N + b = 5 3", + "type": "inline_equation" + }, + { + "bbox": [ + 332, + 362, + 506, + 375 + ], + "score": 1.0, + "content": "workers, 17 parameter servers were used;", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 372, + 506, + 386 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 121, + 386 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 121, + 374, + 179, + 384 + ], + "score": 0.91, + "content": "N + b = 1 0 6", + "type": "inline_equation" + }, + { + "bbox": [ + 179, + 372, + 506, + 386 + ], + "score": 1.0, + "content": "workers, we used 27 parameter servers; and 37 parameter servers were used for", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 107, + 384, + 165, + 396 + ], + "spans": [ + { + "bbox": [ + 107, + 385, + 161, + 395 + ], + "score": 0.88, + "content": "N + b = 2 1 2", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 384, + 165, + 396 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 18.5, + "bbox_fs": [ + 105, + 352, + 506, + 396 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 401, + 505, + 467 + ], + "lines": [ + { + "bbox": [ + 105, + 401, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 505, + 414 + ], + "score": 1.0, + "content": "In the asynchronous training mode, gradient clipping is also needed for stabilization, which requires", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 413, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 505, + 424 + ], + "score": 1.0, + "content": "each worker to collect the gradient across all layers of the deep model, compute the global norm", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 107, + 423, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 107, + 423, + 127, + 435 + ], + "score": 0.9, + "content": "| | G | |", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 423, + 505, + 436 + ], + "score": 1.0, + "content": "and then clip all gradient accordingly. However, synchronization turns out to be very stable so", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 433, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 506, + 447 + ], + "score": 1.0, + "content": "gradient clipping is no longer needed, which means that we can pipeline the update of parameters", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 444, + 505, + 458 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 505, + 458 + ], + "score": 1.0, + "content": "in different layers: the gradient of top layers’ parameters can be sent to parameter servers while", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 456, + 326, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 326, + 469 + ], + "score": 1.0, + "content": "concurrently computing gradients for the lower layers.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 401, + 506, + 469 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 472, + 505, + 553 + ], + "lines": [ + { + "bbox": [ + 106, + 473, + 505, + 485 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 505, + 485 + ], + "score": 1.0, + "content": "The underlying optimizer is RMSProp with momentum, with decay of 0.9 and momentum of 0.9.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 483, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 172, + 497 + ], + "score": 1.0, + "content": "Mini-batch size", + "type": "text" + }, + { + "bbox": [ + 173, + 484, + 208, + 494 + ], + "score": 0.89, + "content": "B = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 483, + 339, + 497 + ], + "score": 1.0, + "content": "was used. Initial learning rates", + "type": "text" + }, + { + "bbox": [ + 339, + 486, + 351, + 496 + ], + "score": 0.85, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 483, + 505, + 497 + ], + "score": 1.0, + "content": "for Async-Opt were set to 0.045; for", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 494, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 356, + 507 + ], + "score": 1.0, + "content": "Sync-Opt, we found as a rule-of-thumb that a learning rate of", + "type": "text" + }, + { + "bbox": [ + 357, + 495, + 390, + 505 + ], + "score": 0.86, + "content": "0 . 0 4 5 N", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 494, + 505, + 507 + ], + "score": 1.0, + "content": "worked well for this model.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 504, + 505, + 521 + ], + "spans": [ + { + "bbox": [ + 104, + 504, + 365, + 521 + ], + "score": 1.0, + "content": "Learning rates were then exponentially decayed with decay rate", + "type": "text" + }, + { + "bbox": [ + 365, + 507, + 405, + 518 + ], + "score": 0.9, + "content": "\\beta = 0 . 9 4", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 504, + 417, + 521 + ], + "score": 1.0, + "content": "as", + "type": "text" + }, + { + "bbox": [ + 417, + 506, + 457, + 519 + ], + "score": 0.93, + "content": "\\gamma _ { 0 } \\beta ^ { t / ( 2 T ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 504, + 505, + 521 + ], + "score": 1.0, + "content": "for Async-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 517, + 506, + 531 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 152, + 531 + ], + "score": 1.0, + "content": "Opt, where", + "type": "text" + }, + { + "bbox": [ + 153, + 518, + 201, + 530 + ], + "score": 0.93, + "content": "T = | { \\mathcal { X } } | / B", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 517, + 506, + 531 + ], + "score": 1.0, + "content": "is the number of mini-batches in the dataset. For Sync-Opt, we learning rates", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 104, + 526, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 104, + 526, + 285, + 545 + ], + "score": 1.0, + "content": "were also exponentially decreased at rate of", + "type": "text" + }, + { + "bbox": [ + 286, + 529, + 332, + 542 + ], + "score": 0.93, + "content": "\\gamma _ { 0 } \\beta ^ { t N / ( 2 T ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 526, + 506, + 545 + ], + "score": 1.0, + "content": ", so that the learning rates after computing", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 540, + 416, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 416, + 555 + ], + "score": 1.0, + "content": "the same number of datapoints are comparable for Async-Opt and Sync-Opt.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 30, + "bbox_fs": [ + 104, + 473, + 506, + 555 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 558, + 454, + 569 + ], + "lines": [ + { + "bbox": [ + 105, + 556, + 452, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 372, + 572 + ], + "score": 1.0, + "content": "Test precisions were evaluated on the exponential moving average", + "type": "text" + }, + { + "bbox": [ + 372, + 557, + 379, + 568 + ], + "score": 0.8, + "content": "\\bar { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 556, + 403, + 572 + ], + "score": 1.0, + "content": "using", + "type": "text" + }, + { + "bbox": [ + 403, + 558, + 452, + 569 + ], + "score": 0.82, + "content": "\\alpha = 0 . 9 9 9 9", + "type": "inline_equation" + } + ], + "index": 34 + } + ], + "index": 34, + "bbox_fs": [ + 105, + 556, + 452, + 572 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 582, + 243, + 594 + ], + "lines": [ + { + "bbox": [ + 106, + 582, + 244, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 582, + 244, + 595 + ], + "score": 1.0, + "content": "A.4 PIXELCNN, SECTION 4.3", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 603, + 505, + 669 + ], + "lines": [ + { + "bbox": [ + 106, + 602, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 106, + 602, + 505, + 617 + ], + "score": 1.0, + "content": "The PixelCNN (Oord et al., 2016) model was trained on the CIFAR-10 (Krizhevsky & Hinton,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 614, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 614, + 238, + 628 + ], + "score": 1.0, + "content": "2009) dataset. Configurations of", + "type": "text" + }, + { + "bbox": [ + 239, + 615, + 307, + 626 + ], + "score": 0.86, + "content": "N + b = 1 , 8 , 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 614, + 390, + 628 + ], + "score": 1.0, + "content": "workers each with a", + "type": "text" + }, + { + "bbox": [ + 390, + 615, + 407, + 625 + ], + "score": 0.45, + "content": "\\mathbf { k } 8 0", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 614, + 505, + 628 + ], + "score": 1.0, + "content": "GPU, and 10 parameter", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 626, + 505, + 638 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 309, + 638 + ], + "score": 1.0, + "content": "servers were used. For Sync-Opt, we always used", + "type": "text" + }, + { + "bbox": [ + 309, + 626, + 334, + 636 + ], + "score": 0.89, + "content": "b = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 626, + 505, + 638 + ], + "score": 1.0, + "content": "backup worker. The underlying optimizer", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 104, + 634, + 504, + 651 + ], + "spans": [ + { + "bbox": [ + 104, + 634, + 492, + 651 + ], + "score": 1.0, + "content": "is RMSProp with momentum, using decay of 0.95 and momentum of 0.9. Initial learning rates", + "type": "text" + }, + { + "bbox": [ + 493, + 639, + 504, + 648 + ], + "score": 0.82, + "content": "\\gamma _ { 0 }", + "type": "inline_equation" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 648, + 504, + 659 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 153, + 659 + ], + "score": 1.0, + "content": "were set to", + "type": "text" + }, + { + "bbox": [ + 153, + 648, + 181, + 658 + ], + "score": 0.74, + "content": "1 e - 4", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 648, + 281, + 659 + ], + "score": 1.0, + "content": "and slowly decreased to", + "type": "text" + }, + { + "bbox": [ + 281, + 648, + 310, + 658 + ], + "score": 0.85, + "content": "3 e - 6", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 648, + 475, + 659 + ], + "score": 1.0, + "content": "after 200,000 iterations. Mini-batch size", + "type": "text" + }, + { + "bbox": [ + 475, + 648, + 504, + 658 + ], + "score": 0.88, + "content": "B = 4", + "type": "inline_equation" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 658, + 148, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 148, + 669 + ], + "score": 1.0, + "content": "was used.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 38.5, + "bbox_fs": [ + 104, + 602, + 505, + 669 + ] + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file