diff --git "a/parse/train/BkJsCIcgl/BkJsCIcgl_middle.json" "b/parse/train/BkJsCIcgl/BkJsCIcgl_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/BkJsCIcgl/BkJsCIcgl_middle.json" @@ -0,0 +1,39518 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 79, + 412, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 78, + 247, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 78, + 247, + 96 + ], + "score": 1.0, + "content": "THE PREDICTRON:", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 98, + 414, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 98, + 414, + 117 + ], + "score": 1.0, + "content": "END-TO-END LEARNING AND PLANNING", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 113, + 131, + 510, + 177 + ], + "lines": [ + { + "bbox": [ + 110, + 129, + 510, + 145 + ], + "spans": [ + { + "bbox": [ + 110, + 129, + 510, + 145 + ], + "score": 1.0, + "content": "David Silver*, Hado van Hasselt*, Matteo Hessel*, Tom Schaul*, Arthur Guez*, Tim Harley,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 111, + 142, + 489, + 156 + ], + "spans": [ + { + "bbox": [ + 111, + 142, + 489, + 156 + ], + "score": 1.0, + "content": "Gabriel Dulac-Arnold, David Reichert, Neil Rabinowitz, Andre Barreto, Thomas Degris", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 110, + 153, + 194, + 167 + ], + "spans": [ + { + "bbox": [ + 110, + 153, + 194, + 167 + ], + "score": 1.0, + "content": "DeepMind, London", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 111, + 163, + 407, + 179 + ], + "spans": [ + { + "bbox": [ + 111, + 163, + 407, + 179 + ], + "score": 1.0, + "content": "{davidsilver,hado,mtthss,schaul,aguez}@google.com", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5 + }, + { + "type": "title", + "bbox": [ + 278, + 191, + 333, + 203 + ], + "lines": [ + { + "bbox": [ + 277, + 190, + 335, + 204 + ], + "spans": [ + { + "bbox": [ + 277, + 190, + 335, + 204 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 143, + 213, + 468, + 323 + ], + "lines": [ + { + "bbox": [ + 142, + 213, + 469, + 225 + ], + "spans": [ + { + "bbox": [ + 142, + 213, + 469, + 225 + ], + "score": 1.0, + "content": "One of the key challenges of artificial intelligence is to learn models that are ef-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 142, + 225, + 469, + 236 + ], + "spans": [ + { + "bbox": [ + 142, + 225, + 469, + 236 + ], + "score": 1.0, + "content": "fective in the context of planning. In this document we introduce the predictron", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 234, + 470, + 248 + ], + "spans": [ + { + "bbox": [ + 141, + 234, + 470, + 248 + ], + "score": 1.0, + "content": "architecture. The predictron consists of a fully abstract model, represented by a", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 246, + 470, + 259 + ], + "spans": [ + { + "bbox": [ + 141, + 246, + 470, + 259 + ], + "score": 1.0, + "content": "Markov reward process, that can be rolled forward multiple “imagined” planning", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 257, + 469, + 269 + ], + "spans": [ + { + "bbox": [ + 141, + 257, + 469, + 269 + ], + "score": 1.0, + "content": "steps. Each forward pass of the predictron accumulates internal rewards and val-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 268, + 470, + 280 + ], + "spans": [ + { + "bbox": [ + 141, + 268, + 470, + 280 + ], + "score": 1.0, + "content": "ues over multiple planning depths. The predictron is trained end-to-end so as to", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 142, + 280, + 469, + 291 + ], + "spans": [ + { + "bbox": [ + 142, + 280, + 469, + 291 + ], + "score": 1.0, + "content": "make these accumulated values accurately approximate the true value function.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 142, + 290, + 470, + 303 + ], + "spans": [ + { + "bbox": [ + 142, + 290, + 470, + 303 + ], + "score": 1.0, + "content": "We applied the predictron to procedurally generated random mazes and a sim-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 301, + 469, + 314 + ], + "spans": [ + { + "bbox": [ + 141, + 301, + 469, + 314 + ], + "score": 1.0, + "content": "ulator for the game of pool. The predictron yielded significantly more accurate", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 312, + 402, + 324 + ], + "spans": [ + { + "bbox": [ + 141, + 312, + 402, + 324 + ], + "score": 1.0, + "content": "predictions than conventional deep neural network architectures.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 11.5 + }, + { + "type": "title", + "bbox": [ + 108, + 342, + 205, + 354 + ], + "lines": [ + { + "bbox": [ + 105, + 341, + 208, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 208, + 358 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 364, + 505, + 485 + ], + "lines": [ + { + "bbox": [ + 105, + 363, + 505, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 505, + 377 + ], + "score": 1.0, + "content": "The central idea of model-based reinforcement learning is to decompose the RL problem into two", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 376, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 505, + 388 + ], + "score": 1.0, + "content": "subproblems: learning a model of the environment, and then planning with this model. The model", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 386, + 505, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 505, + 399 + ], + "score": 1.0, + "content": "is typically represented by a Markov reward process (MRP) or decision process (MDP). The plan-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 398, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 505, + 410 + ], + "score": 1.0, + "content": "ning component uses this model to evaluate and select among possible strategies. This is typically", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "score": 1.0, + "content": "achieved by rolling forward the model to construct a value function that estimates cumulative re-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 419, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 505, + 432 + ], + "score": 1.0, + "content": "ward. In prior work, the model is trained essentially independently of its use within the planner.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "score": 1.0, + "content": "As a result, the model is not well-matched with the overall objective of the agent. Prior deep rein-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 441, + 505, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 505, + 454 + ], + "score": 1.0, + "content": "forcement learning methods have successfully constructed models that can unroll near pixel-perfect", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 451, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 505, + 465 + ], + "score": 1.0, + "content": "reconstructions (Oh et al., 2015; Chiappa et al., 2016); but are yet to surpass state-of-the-art model-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 462, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 505, + 477 + ], + "score": 1.0, + "content": "free methods in challenging RL domains with raw inputs (e.g., Mnih et al., 2015; 2016; Lillicrap", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 474, + 160, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 160, + 487 + ], + "score": 1.0, + "content": "et al., 2016).", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 488, + 505, + 630 + ], + "lines": [ + { + "bbox": [ + 105, + 486, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 505, + 502 + ], + "score": 1.0, + "content": "In this paper we introduce a new architecture, which we call the predictron, that integrates learning", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 499, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 105, + 499, + 505, + 512 + ], + "score": 1.0, + "content": "and planning into one end-to-end training procedure. At every step, a model is applied to an internal", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 509, + 506, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 506, + 523 + ], + "score": 1.0, + "content": "state, to produce a next state, reward, discount, and value estimate. This model is completely abstract", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 519, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 519, + 505, + 535 + ], + "score": 1.0, + "content": "and its only goal is to facilitate accurate value prediction. For example, to plan effectively in a game,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 532, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 505, + 545 + ], + "score": 1.0, + "content": "an agent must be able to predict the score. If our model makes accurate predictions, then an optimal", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 542, + 506, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 506, + 555 + ], + "score": 1.0, + "content": "plan with respect to our model will also be an optimal plan for the underlying game – even if that", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 552, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 505, + 568 + ], + "score": 1.0, + "content": "model uses a different state space (e.g., an abstract representation of enemy positions, ignoring", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 565, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 505, + 578 + ], + "score": 1.0, + "content": "their shapes and colours), action space (e.g., a high-level action to move away from an enemy),", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 576, + 505, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 505, + 589 + ], + "score": 1.0, + "content": "rewards (e.g., a single abstract step could have a higher value than any real reward), or even time-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 586, + 505, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 505, + 600 + ], + "score": 1.0, + "content": "step (e.g., a single abstract step could “jump” the agent to the end of a corridor). All we require", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 597, + 505, + 610 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 505, + 610 + ], + "score": 1.0, + "content": "is that trajectories through the abstract model produce scores that are consistent with trajectories", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 608, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 608, + 505, + 621 + ], + "score": 1.0, + "content": "through the real environment. This is achieved by training the predictron end-to-end, so as to make", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 618, + 276, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 276, + 632 + ], + "score": 1.0, + "content": "its value estimates as accurate as possible.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 633, + 504, + 688 + ], + "lines": [ + { + "bbox": [ + 106, + 633, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 106, + 633, + 505, + 645 + ], + "score": 1.0, + "content": "An ideal model could generalise to many different prediction tasks, rather than overfitting to a single", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 645, + 505, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 645, + 505, + 657 + ], + "score": 1.0, + "content": "task; and could learn from a rich variety of feedback signals, not just a single extrinsic reward. We", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 655, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 668 + ], + "score": 1.0, + "content": "therefore train the predictron to predict a host of different value functions for a variety of pseudo-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 665, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 680 + ], + "score": 1.0, + "content": "reward functions and discount factors. These pseudo-rewards can encode any event or aspect of the", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 678, + 460, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 678, + 460, + 690 + ], + "score": 1.0, + "content": "environment that the agent may care about, e.g., staying alive or reaching the next room.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 44 + }, + { + "type": "text", + "bbox": [ + 108, + 691, + 504, + 713 + ], + "lines": [ + { + "bbox": [ + 106, + 690, + 505, + 704 + ], + "spans": [ + { + "bbox": [ + 106, + 690, + 505, + 704 + ], + "score": 1.0, + "content": "We focus upon the prediction task: estimating value functions in MRP environments with uncon-", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 701, + 505, + 714 + ], + "spans": [ + { + "bbox": [ + 106, + 701, + 505, + 714 + ], + "score": 1.0, + "content": "trolled dynamics. In this case, the predictron can be implemented as a deep neural network with an", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47.5 + } + ], + "page_idx": 0, + "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": [ + 123, + 722, + 203, + 731 + ], + "lines": [ + { + "bbox": [ + 122, + 720, + 204, + 733 + ], + "spans": [ + { + "bbox": [ + 122, + 720, + 204, + 733 + ], + "score": 1.0, + "content": "*Primary contributors", + "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": [ + 107, + 79, + 412, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 78, + 247, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 78, + 247, + 96 + ], + "score": 1.0, + "content": "THE PREDICTRON:", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 98, + 414, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 98, + 414, + 117 + ], + "score": 1.0, + "content": "END-TO-END LEARNING AND PLANNING", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 113, + 131, + 510, + 177 + ], + "lines": [ + { + "bbox": [ + 110, + 129, + 510, + 145 + ], + "spans": [ + { + "bbox": [ + 110, + 129, + 510, + 145 + ], + "score": 1.0, + "content": "David Silver*, Hado van Hasselt*, Matteo Hessel*, Tom Schaul*, Arthur Guez*, Tim Harley,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 111, + 142, + 489, + 156 + ], + "spans": [ + { + "bbox": [ + 111, + 142, + 489, + 156 + ], + "score": 1.0, + "content": "Gabriel Dulac-Arnold, David Reichert, Neil Rabinowitz, Andre Barreto, Thomas Degris", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 110, + 153, + 194, + 167 + ], + "spans": [ + { + "bbox": [ + 110, + 153, + 194, + 167 + ], + "score": 1.0, + "content": "DeepMind, London", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 111, + 163, + 407, + 179 + ], + "spans": [ + { + "bbox": [ + 111, + 163, + 407, + 179 + ], + "score": 1.0, + "content": "{davidsilver,hado,mtthss,schaul,aguez}@google.com", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5, + "bbox_fs": [ + 110, + 129, + 510, + 179 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 191, + 333, + 203 + ], + "lines": [ + { + "bbox": [ + 277, + 190, + 335, + 204 + ], + "spans": [ + { + "bbox": [ + 277, + 190, + 335, + 204 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 143, + 213, + 468, + 323 + ], + "lines": [ + { + "bbox": [ + 142, + 213, + 469, + 225 + ], + "spans": [ + { + "bbox": [ + 142, + 213, + 469, + 225 + ], + "score": 1.0, + "content": "One of the key challenges of artificial intelligence is to learn models that are ef-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 142, + 225, + 469, + 236 + ], + "spans": [ + { + "bbox": [ + 142, + 225, + 469, + 236 + ], + "score": 1.0, + "content": "fective in the context of planning. In this document we introduce the predictron", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 234, + 470, + 248 + ], + "spans": [ + { + "bbox": [ + 141, + 234, + 470, + 248 + ], + "score": 1.0, + "content": "architecture. The predictron consists of a fully abstract model, represented by a", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 246, + 470, + 259 + ], + "spans": [ + { + "bbox": [ + 141, + 246, + 470, + 259 + ], + "score": 1.0, + "content": "Markov reward process, that can be rolled forward multiple “imagined” planning", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 257, + 469, + 269 + ], + "spans": [ + { + "bbox": [ + 141, + 257, + 469, + 269 + ], + "score": 1.0, + "content": "steps. Each forward pass of the predictron accumulates internal rewards and val-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 268, + 470, + 280 + ], + "spans": [ + { + "bbox": [ + 141, + 268, + 470, + 280 + ], + "score": 1.0, + "content": "ues over multiple planning depths. The predictron is trained end-to-end so as to", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 142, + 280, + 469, + 291 + ], + "spans": [ + { + "bbox": [ + 142, + 280, + 469, + 291 + ], + "score": 1.0, + "content": "make these accumulated values accurately approximate the true value function.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 142, + 290, + 470, + 303 + ], + "spans": [ + { + "bbox": [ + 142, + 290, + 470, + 303 + ], + "score": 1.0, + "content": "We applied the predictron to procedurally generated random mazes and a sim-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 301, + 469, + 314 + ], + "spans": [ + { + "bbox": [ + 141, + 301, + 469, + 314 + ], + "score": 1.0, + "content": "ulator for the game of pool. The predictron yielded significantly more accurate", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 312, + 402, + 324 + ], + "spans": [ + { + "bbox": [ + 141, + 312, + 402, + 324 + ], + "score": 1.0, + "content": "predictions than conventional deep neural network architectures.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 11.5, + "bbox_fs": [ + 141, + 213, + 470, + 324 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 342, + 205, + 354 + ], + "lines": [ + { + "bbox": [ + 105, + 341, + 208, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 208, + 358 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 364, + 505, + 485 + ], + "lines": [ + { + "bbox": [ + 105, + 363, + 505, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 505, + 377 + ], + "score": 1.0, + "content": "The central idea of model-based reinforcement learning is to decompose the RL problem into two", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 376, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 505, + 388 + ], + "score": 1.0, + "content": "subproblems: learning a model of the environment, and then planning with this model. The model", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 386, + 505, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 505, + 399 + ], + "score": 1.0, + "content": "is typically represented by a Markov reward process (MRP) or decision process (MDP). The plan-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 398, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 505, + 410 + ], + "score": 1.0, + "content": "ning component uses this model to evaluate and select among possible strategies. This is typically", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "score": 1.0, + "content": "achieved by rolling forward the model to construct a value function that estimates cumulative re-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 419, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 505, + 432 + ], + "score": 1.0, + "content": "ward. In prior work, the model is trained essentially independently of its use within the planner.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "score": 1.0, + "content": "As a result, the model is not well-matched with the overall objective of the agent. Prior deep rein-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 441, + 505, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 505, + 454 + ], + "score": 1.0, + "content": "forcement learning methods have successfully constructed models that can unroll near pixel-perfect", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 451, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 505, + 465 + ], + "score": 1.0, + "content": "reconstructions (Oh et al., 2015; Chiappa et al., 2016); but are yet to surpass state-of-the-art model-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 462, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 505, + 477 + ], + "score": 1.0, + "content": "free methods in challenging RL domains with raw inputs (e.g., Mnih et al., 2015; 2016; Lillicrap", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 474, + 160, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 160, + 487 + ], + "score": 1.0, + "content": "et al., 2016).", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 363, + 505, + 487 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 488, + 505, + 630 + ], + "lines": [ + { + "bbox": [ + 105, + 486, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 505, + 502 + ], + "score": 1.0, + "content": "In this paper we introduce a new architecture, which we call the predictron, that integrates learning", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 499, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 105, + 499, + 505, + 512 + ], + "score": 1.0, + "content": "and planning into one end-to-end training procedure. At every step, a model is applied to an internal", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 509, + 506, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 506, + 523 + ], + "score": 1.0, + "content": "state, to produce a next state, reward, discount, and value estimate. This model is completely abstract", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 519, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 519, + 505, + 535 + ], + "score": 1.0, + "content": "and its only goal is to facilitate accurate value prediction. For example, to plan effectively in a game,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 532, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 505, + 545 + ], + "score": 1.0, + "content": "an agent must be able to predict the score. If our model makes accurate predictions, then an optimal", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 542, + 506, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 506, + 555 + ], + "score": 1.0, + "content": "plan with respect to our model will also be an optimal plan for the underlying game – even if that", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 552, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 505, + 568 + ], + "score": 1.0, + "content": "model uses a different state space (e.g., an abstract representation of enemy positions, ignoring", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 565, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 505, + 578 + ], + "score": 1.0, + "content": "their shapes and colours), action space (e.g., a high-level action to move away from an enemy),", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 576, + 505, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 505, + 589 + ], + "score": 1.0, + "content": "rewards (e.g., a single abstract step could have a higher value than any real reward), or even time-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 586, + 505, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 505, + 600 + ], + "score": 1.0, + "content": "step (e.g., a single abstract step could “jump” the agent to the end of a corridor). All we require", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 597, + 505, + 610 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 505, + 610 + ], + "score": 1.0, + "content": "is that trajectories through the abstract model produce scores that are consistent with trajectories", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 608, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 608, + 505, + 621 + ], + "score": 1.0, + "content": "through the real environment. This is achieved by training the predictron end-to-end, so as to make", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 618, + 276, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 276, + 632 + ], + "score": 1.0, + "content": "its value estimates as accurate as possible.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 486, + 506, + 632 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 633, + 504, + 688 + ], + "lines": [ + { + "bbox": [ + 106, + 633, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 106, + 633, + 505, + 645 + ], + "score": 1.0, + "content": "An ideal model could generalise to many different prediction tasks, rather than overfitting to a single", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 645, + 505, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 645, + 505, + 657 + ], + "score": 1.0, + "content": "task; and could learn from a rich variety of feedback signals, not just a single extrinsic reward. We", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 655, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 668 + ], + "score": 1.0, + "content": "therefore train the predictron to predict a host of different value functions for a variety of pseudo-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 665, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 680 + ], + "score": 1.0, + "content": "reward functions and discount factors. These pseudo-rewards can encode any event or aspect of the", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 678, + 460, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 678, + 460, + 690 + ], + "score": 1.0, + "content": "environment that the agent may care about, e.g., staying alive or reaching the next room.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 44, + "bbox_fs": [ + 105, + 633, + 506, + 690 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 691, + 504, + 713 + ], + "lines": [ + { + "bbox": [ + 106, + 690, + 505, + 704 + ], + "spans": [ + { + "bbox": [ + 106, + 690, + 505, + 704 + ], + "score": 1.0, + "content": "We focus upon the prediction task: estimating value functions in MRP environments with uncon-", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 701, + 505, + 714 + ], + "spans": [ + { + "bbox": [ + 106, + 701, + 505, + 714 + ], + "score": 1.0, + "content": "trolled dynamics. In this case, the predictron can be implemented as a deep neural network with an", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47.5, + "bbox_fs": [ + 106, + 690, + 505, + 714 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "MRP as a recurrent core. The predictron unrolls this core multiple steps and accumulates rewards", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 239, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 239, + 105 + ], + "score": 1.0, + "content": "into an overall estimate of value.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 107, + 107, + 505, + 151 + ], + "lines": [ + { + "bbox": [ + 105, + 106, + 505, + 120 + ], + "spans": [ + { + "bbox": [ + 105, + 106, + 505, + 120 + ], + "score": 1.0, + "content": "We applied the predictron to procedurally generated random mazes, and a simulated pool domain,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 118, + 505, + 130 + ], + "spans": [ + { + "bbox": [ + 106, + 118, + 505, + 130 + ], + "score": 1.0, + "content": "directly from pixel inputs. In both cases, the predictron significantly outperformed model-free al-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 129, + 505, + 141 + ], + "spans": [ + { + "bbox": [ + 105, + 129, + 505, + 141 + ], + "score": 1.0, + "content": "gorithms with conventional deep network architectures; and was much more robust to architectural", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 141, + 196, + 152 + ], + "spans": [ + { + "bbox": [ + 106, + 141, + 196, + 152 + ], + "score": 1.0, + "content": "choices such as depth.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5 + }, + { + "type": "title", + "bbox": [ + 108, + 165, + 200, + 178 + ], + "lines": [ + { + "bbox": [ + 104, + 163, + 202, + 181 + ], + "spans": [ + { + "bbox": [ + 104, + 163, + 202, + 181 + ], + "score": 1.0, + "content": "2 BACKGROUND", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 187, + 505, + 231 + ], + "lines": [ + { + "bbox": [ + 105, + 186, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 337, + 200 + ], + "score": 1.0, + "content": "We consider environments defined by an MRP with states", + "type": "text" + }, + { + "bbox": [ + 337, + 188, + 362, + 198 + ], + "score": 0.9, + "content": "s \\in S", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 186, + 505, + 200 + ], + "score": 1.0, + "content": ". The MRP is defined by a function,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 107, + 198, + 506, + 211 + ], + "spans": [ + { + "bbox": [ + 107, + 198, + 178, + 210 + ], + "score": 0.92, + "content": "s ^ { \\prime } , r , \\gamma = p ( s , \\alpha )", + "type": "inline_equation" + }, + { + "bbox": [ + 179, + 198, + 211, + 211 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 212, + 199, + 220, + 208 + ], + "score": 0.85, + "content": "s ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 221, + 198, + 292, + 211 + ], + "score": 1.0, + "content": "is the next state,", + "type": "text" + }, + { + "bbox": [ + 293, + 201, + 299, + 208 + ], + "score": 0.71, + "content": "r", + "type": "inline_equation" + }, + { + "bbox": [ + 299, + 198, + 377, + 211 + ], + "score": 1.0, + "content": "is the reward, and", + "type": "text" + }, + { + "bbox": [ + 377, + 200, + 385, + 210 + ], + "score": 0.83, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 198, + 506, + 211 + ], + "score": 1.0, + "content": "is the discount factor, which", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 210, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 505, + 223 + ], + "score": 1.0, + "content": "can for instance represent the non-termination probability for this transition. The process may be", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 221, + 227, + 233 + ], + "spans": [ + { + "bbox": [ + 106, + 221, + 214, + 233 + ], + "score": 1.0, + "content": "stochastic, given IID noise", + "type": "text" + }, + { + "bbox": [ + 215, + 222, + 222, + 230 + ], + "score": 0.71, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 223, + 221, + 227, + 233 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 107, + 234, + 505, + 300 + ], + "lines": [ + { + "bbox": [ + 106, + 233, + 504, + 248 + ], + "spans": [ + { + "bbox": [ + 106, + 233, + 450, + 248 + ], + "score": 1.0, + "content": "The return of an MRP is the cumulative discounted reward over a single trajectory,", + "type": "text" + }, + { + "bbox": [ + 450, + 236, + 504, + 246 + ], + "score": 0.88, + "content": "g _ { t } = r _ { t + 1 } +", + "type": "inline_equation" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 245, + 505, + 258 + ], + "spans": [ + { + "bbox": [ + 106, + 246, + 231, + 257 + ], + "score": 0.9, + "content": "\\gamma _ { t + 1 } r _ { t + 2 } + \\gamma _ { t + 1 } \\gamma _ { t + 2 } r _ { t + 3 } + \\ldots ,", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 245, + 259, + 258 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 260, + 247, + 270, + 257 + ], + "score": 0.86, + "content": "\\gamma _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 245, + 505, + 258 + ], + "score": 1.0, + "content": "can vary per time-step. We consider a generalisation of the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 257, + 505, + 268 + ], + "spans": [ + { + "bbox": [ + 106, + 257, + 303, + 268 + ], + "score": 1.0, + "content": "MRP setting that includes vector-valued rewards", + "type": "text" + }, + { + "bbox": [ + 304, + 258, + 310, + 266 + ], + "score": 0.27, + "content": "\\mathbf { r }", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 257, + 420, + 268 + ], + "score": 1.0, + "content": ", diagonal-matrix discounts", + "type": "text" + }, + { + "bbox": [ + 420, + 258, + 427, + 268 + ], + "score": 0.76, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 257, + 505, + 268 + ], + "score": 1.0, + "content": ", and vector-valued", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 267, + 505, + 280 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 136, + 280 + ], + "score": 1.0, + "content": "returns", + "type": "text" + }, + { + "bbox": [ + 137, + 269, + 144, + 279 + ], + "score": 0.3, + "content": "\\mathbf { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 267, + 505, + 280 + ], + "score": 1.0, + "content": "; definitions are otherwise identical to the above. We use this bold font notation to closely", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 278, + 505, + 291 + ], + "spans": [ + { + "bbox": [ + 105, + 278, + 505, + 291 + ], + "score": 1.0, + "content": "match the more familiar scalar MRP case; the majority of the paper can be comfortably understood", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 288, + 477, + 303 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 444, + 303 + ], + "score": 1.0, + "content": "by reading all rewards as scalars, and all discount factors as scalar and constant, i.e.,", + "type": "text" + }, + { + "bbox": [ + 444, + 291, + 473, + 301 + ], + "score": 0.89, + "content": "\\gamma _ { t } = \\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 288, + 477, + 303 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 107, + 303, + 504, + 347 + ], + "lines": [ + { + "bbox": [ + 105, + 302, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 233, + 316 + ], + "score": 1.0, + "content": "The value function of an MRP", + "type": "text" + }, + { + "bbox": [ + 234, + 304, + 241, + 314 + ], + "score": 0.78, + "content": "p", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 302, + 377, + 316 + ], + "score": 1.0, + "content": "is the expected return from state", + "type": "text" + }, + { + "bbox": [ + 377, + 306, + 383, + 313 + ], + "score": 0.44, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 302, + 388, + 316 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 388, + 302, + 488, + 315 + ], + "score": 0.89, + "content": "v _ { p } ( s ) = \\mathbb { E } _ { p } \\left[ \\mathbf { g } _ { t } \\mid s _ { t } = s \\right]", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 302, + 506, + 316 + ], + "score": 1.0, + "content": ". In", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 313, + 506, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 506, + 326 + ], + "score": 1.0, + "content": "the vector case, these are known as general value functions (Sutton et al., 2011). We will say that a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 205, + 338 + ], + "score": 1.0, + "content": "(general) value function", + "type": "text" + }, + { + "bbox": [ + 205, + 325, + 222, + 337 + ], + "score": 0.91, + "content": "v ( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 325, + 349, + 338 + ], + "score": 1.0, + "content": "is consistent with environment", + "type": "text" + }, + { + "bbox": [ + 349, + 327, + 356, + 336 + ], + "score": 0.83, + "content": "p", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 325, + 412, + 338 + ], + "score": 1.0, + "content": "if and only if", + "type": "text" + }, + { + "bbox": [ + 412, + 326, + 442, + 337 + ], + "score": 0.91, + "content": "v = v _ { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 442, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "which satisfies", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 335, + 306, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 306, + 348 + ], + "score": 1.0, + "content": "the following Bellman equation (Bellman, 1957),", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 18.5 + }, + { + "type": "interline_equation", + "bbox": [ + 245, + 353, + 367, + 367 + ], + "lines": [ + { + "bbox": [ + 245, + 353, + 367, + 367 + ], + "spans": [ + { + "bbox": [ + 245, + 353, + 367, + 367 + ], + "score": 0.92, + "content": "v _ { p } ( s ) = \\mathbb { E } _ { p } \\left[ \\mathbf { r } + \\gamma v _ { p } ( s ^ { \\prime } ) \\mid s \\right] .", + "type": "interline_equation", + "image_path": "592d1d3e31a4ecdf1a1e4f2bf7665fd4a0cd742f9ccc0a118110105edca09678.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 245, + 353, + 367, + 367 + ], + "spans": [], + "index": 21 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 375, + 505, + 453 + ], + "lines": [ + { + "bbox": [ + 106, + 375, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 375, + 447, + 388 + ], + "score": 1.0, + "content": "In model-based reinforcement learning (Sutton and Barto, 1998), an approximation", + "type": "text" + }, + { + "bbox": [ + 447, + 378, + 478, + 387 + ], + "score": 0.87, + "content": "m \\approx p", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 375, + 505, + 388 + ], + "score": 1.0, + "content": "to the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 387, + 504, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 387, + 431, + 399 + ], + "score": 1.0, + "content": "environment is learned. In the uncontrolled setting this model is normally an MRP", + "type": "text" + }, + { + "bbox": [ + 432, + 387, + 504, + 398 + ], + "score": 0.83, + "content": "s ^ { \\prime } , \\mathbf { r } , \\gamma = m ( s , \\beta )", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 396, + 506, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 193, + 411 + ], + "score": 1.0, + "content": "that maps from state", + "type": "text" + }, + { + "bbox": [ + 193, + 400, + 199, + 407 + ], + "score": 0.69, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 200, + 396, + 281, + 411 + ], + "score": 1.0, + "content": "to subsequent state", + "type": "text" + }, + { + "bbox": [ + 281, + 398, + 290, + 407 + ], + "score": 0.85, + "content": "s ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 396, + 427, + 411 + ], + "score": 1.0, + "content": "and additionally outputs rewards", + "type": "text" + }, + { + "bbox": [ + 427, + 399, + 434, + 407 + ], + "score": 0.53, + "content": "\\mathbf { r }", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 396, + 493, + 411 + ], + "score": 1.0, + "content": "and discounts", + "type": "text" + }, + { + "bbox": [ + 493, + 400, + 501, + 409 + ], + "score": 0.76, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 396, + 506, + 411 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 409, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 106, + 409, + 345, + 421 + ], + "score": 1.0, + "content": "the model may be stochastic given an IID source of noise", + "type": "text" + }, + { + "bbox": [ + 345, + 409, + 353, + 420 + ], + "score": 0.83, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 353, + 409, + 469, + 421 + ], + "score": 1.0, + "content": ". A (general) value function", + "type": "text" + }, + { + "bbox": [ + 470, + 409, + 494, + 421 + ], + "score": 0.91, + "content": "v _ { m } ( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 494, + 409, + 506, + 421 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 419, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 106, + 419, + 199, + 431 + ], + "score": 1.0, + "content": "consistent with model", + "type": "text" + }, + { + "bbox": [ + 199, + 421, + 209, + 429 + ], + "score": 0.75, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 419, + 505, + 431 + ], + "score": 1.0, + "content": "(or valid, (Sutton, 1995)), if and only if it satisfies a Bellman equation", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 430, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 106, + 430, + 230, + 443 + ], + "score": 0.9, + "content": "v _ { m } ( s ) = \\mathbb { E } _ { m } \\left[ \\mathbf { r } + \\gamma v _ { m } ( s ^ { \\prime } ) \\mid s \\right]", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 430, + 320, + 443 + ], + "score": 1.0, + "content": "with respect to model", + "type": "text" + }, + { + "bbox": [ + 320, + 432, + 330, + 441 + ], + "score": 0.74, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 430, + 505, + 443 + ], + "score": 1.0, + "content": ". Conventionally, model-based RL methods", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 442, + 460, + 454 + ], + "spans": [ + { + "bbox": [ + 106, + 442, + 240, + 454 + ], + "score": 1.0, + "content": "focus on finding a value function", + "type": "text" + }, + { + "bbox": [ + 240, + 444, + 246, + 451 + ], + "score": 0.74, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 247, + 442, + 446, + 454 + ], + "score": 1.0, + "content": "that is consistent with a separately learned model", + "type": "text" + }, + { + "bbox": [ + 446, + 443, + 456, + 451 + ], + "score": 0.74, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 442, + 460, + 454 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 25 + }, + { + "type": "title", + "bbox": [ + 108, + 466, + 277, + 479 + ], + "lines": [ + { + "bbox": [ + 105, + 465, + 280, + 481 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 280, + 481 + ], + "score": 1.0, + "content": "3 PREDICTRON ARCHITECTURE", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 488, + 505, + 621 + ], + "lines": [ + { + "bbox": [ + 105, + 488, + 506, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 445, + 502 + ], + "score": 1.0, + "content": "The predictron is composed of four main components. First, a state representation", + "type": "text" + }, + { + "bbox": [ + 446, + 489, + 486, + 501 + ], + "score": 0.92, + "content": "\\mathbf { s } = f ( s )", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 488, + 506, + 502 + ], + "score": 1.0, + "content": "that", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 500, + 504, + 511 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 183, + 511 + ], + "score": 1.0, + "content": "encodes raw input", + "type": "text" + }, + { + "bbox": [ + 184, + 502, + 190, + 510 + ], + "score": 0.66, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 500, + 504, + 511 + ], + "score": 1.0, + "content": "(this could be a history of observations, in the partially observed setting, for", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 511, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 167, + 523 + ], + "score": 1.0, + "content": "example when", + "type": "text" + }, + { + "bbox": [ + 167, + 511, + 174, + 522 + ], + "score": 0.84, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 511, + 505, + 523 + ], + "score": 1.0, + "content": "is a recurrent network) into an internal (abstract, hidden) state s. Second, a model", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 522, + 506, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 522, + 180, + 533 + ], + "score": 0.91, + "content": "\\mathbf { s } ^ { \\prime } , \\mathbf { r } , \\gamma = m ( \\mathbf { s } , \\beta )", + "type": "inline_equation" + }, + { + "bbox": [ + 180, + 522, + 415, + 534 + ], + "score": 1.0, + "content": "that maps from internal state s to subsequent internal state", + "type": "text" + }, + { + "bbox": [ + 416, + 522, + 424, + 532 + ], + "score": 0.84, + "content": "\\mathbf { s } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 522, + 495, + 534 + ], + "score": 1.0, + "content": ", internal rewards", + "type": "text" + }, + { + "bbox": [ + 495, + 524, + 501, + 532 + ], + "score": 0.42, + "content": "\\mathbf { r }", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 522, + 506, + 534 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 532, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 195, + 546 + ], + "score": 1.0, + "content": "and internal discounts", + "type": "text" + }, + { + "bbox": [ + 195, + 534, + 202, + 545 + ], + "score": 0.8, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 532, + 298, + 546 + ], + "score": 1.0, + "content": ". Third, a value function", + "type": "text" + }, + { + "bbox": [ + 299, + 535, + 305, + 543 + ], + "score": 0.68, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 532, + 414, + 546 + ], + "score": 1.0, + "content": "that outputs internal values", + "type": "text" + }, + { + "bbox": [ + 414, + 533, + 452, + 545 + ], + "score": 0.92, + "content": "\\mathbf { v } = v ( \\mathbf { s } )", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 532, + 506, + 546 + ], + "score": 1.0, + "content": "representing", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 543, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 505, + 556 + ], + "score": 1.0, + "content": "the future, internal return from internal state s onwards. The predictron is applied by unrolling its", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 554, + 506, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 135, + 567 + ], + "score": 1.0, + "content": "model", + "type": "text" + }, + { + "bbox": [ + 135, + 556, + 146, + 565 + ], + "score": 0.75, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 554, + 506, + 567 + ], + "score": 1.0, + "content": "multiple “planning” steps to produce internal rewards, discounts and values. We use", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 565, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 156, + 578 + ], + "score": 1.0, + "content": "superscripts", + "type": "text" + }, + { + "bbox": [ + 156, + 565, + 168, + 576 + ], + "score": 0.85, + "content": "\\bullet ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 565, + 506, + 578 + ], + "score": 1.0, + "content": "to indicate internal steps of the model (which have no necessary connection to time", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 577, + 506, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 129, + 588 + ], + "score": 1.0, + "content": "steps", + "type": "text" + }, + { + "bbox": [ + 129, + 578, + 140, + 588 + ], + "score": 0.84, + "content": "\\bullet _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 577, + 506, + 588 + ], + "score": 1.0, + "content": "of the environment). Finally, these internal rewards, discounts and values are combined", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 587, + 506, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 506, + 600 + ], + "score": 1.0, + "content": "together by an accumulator into an overall estimate of value g. The whole predictron, from input", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 599, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 128, + 611 + ], + "score": 1.0, + "content": "state", + "type": "text" + }, + { + "bbox": [ + 128, + 601, + 134, + 608 + ], + "score": 0.73, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 135, + 599, + 505, + 611 + ], + "score": 1.0, + "content": "to output g, may be viewed as a value function approximator for external targets (i.e. the", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 609, + 460, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 309, + 622 + ], + "score": 1.0, + "content": "returns in the real environment). We consider both", + "type": "text" + }, + { + "bbox": [ + 310, + 610, + 317, + 619 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 609, + 354, + 622 + ], + "score": 1.0, + "content": "-step and", + "type": "text" + }, + { + "bbox": [ + 354, + 610, + 361, + 619 + ], + "score": 0.79, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 609, + 460, + 622 + ], + "score": 1.0, + "content": "-weighted accumulators.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 107, + 623, + 505, + 657 + ], + "lines": [ + { + "bbox": [ + 106, + 622, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 106, + 622, + 125, + 636 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 125, + 623, + 132, + 633 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 622, + 328, + 636 + ], + "score": 1.0, + "content": "-step predictron rolls its internal model forward", + "type": "text" + }, + { + "bbox": [ + 328, + 623, + 335, + 633 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 622, + 433, + 636 + ], + "score": 1.0, + "content": "steps. Specifically, the", + "type": "text" + }, + { + "bbox": [ + 433, + 623, + 440, + 633 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 440, + 622, + 505, + 636 + ], + "score": 1.0, + "content": "-step predictron", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 633, + 504, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 134, + 646 + ], + "score": 1.0, + "content": "return", + "type": "text" + }, + { + "bbox": [ + 135, + 634, + 147, + 646 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 147, + 633, + 497, + 646 + ], + "score": 1.0, + "content": "(henceforth abbreviated as preturn) is the internal return obtained by accumulating", + "type": "text" + }, + { + "bbox": [ + 497, + 635, + 504, + 644 + ], + "score": 0.77, + "content": "k", + "type": "inline_equation" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 644, + 316, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 228, + 658 + ], + "score": 1.0, + "content": "model steps, plus a final value", + "type": "text" + }, + { + "bbox": [ + 229, + 644, + 241, + 655 + ], + "score": 0.88, + "content": "\\mathbf { v } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 644, + 279, + 658 + ], + "score": 1.0, + "content": "from the", + "type": "text" + }, + { + "bbox": [ + 279, + 646, + 285, + 655 + ], + "score": 0.4, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 644, + 316, + 658 + ], + "score": 1.0, + "content": "th step,", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43 + }, + { + "type": "interline_equation", + "bbox": [ + 182, + 662, + 428, + 678 + ], + "lines": [ + { + "bbox": [ + 182, + 662, + 428, + 678 + ], + "spans": [ + { + "bbox": [ + 182, + 662, + 428, + 678 + ], + "score": 0.9, + "content": "\\mathbf { g } ^ { k } = \\mathbf { r } ^ { 1 } + \\gamma ^ { 1 } ( \\mathbf { r } ^ { 2 } + \\gamma ^ { 2 } ( \\ldots ( \\mathbf { r } ^ { k - 1 } + \\gamma ^ { k - 1 } ( \\mathbf { r } ^ { k } + \\gamma ^ { k } \\mathbf { v } ^ { k } ) ) \\ldots ) ) .", + "type": "interline_equation", + "image_path": "3a50df1e4acdaaa18efc0491d17fa4c0272053b7e0b3186b85a705a0d0b8f4f4.jpg" + } + ] + } + ], + "index": 45, + "virtual_lines": [ + { + "bbox": [ + 182, + 662, + 428, + 678 + ], + "spans": [], + "index": 45 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 684, + 504, + 708 + ], + "lines": [ + { + "bbox": [ + 105, + 682, + 506, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 279, + 698 + ], + "score": 1.0, + "content": "The 0-step preturn is simply the first value", + "type": "text" + }, + { + "bbox": [ + 279, + 684, + 315, + 696 + ], + "score": 0.91, + "content": "\\mathbf { g } ^ { 0 } = \\mathbf { v } ^ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 682, + 405, + 698 + ], + "score": 1.0, + "content": ". The 1-step preturn is", + "type": "text" + }, + { + "bbox": [ + 405, + 684, + 473, + 696 + ], + "score": 0.92, + "content": "\\mathbf { g } ^ { 1 } = \\mathbf { r } ^ { 1 } + \\gamma ^ { 1 } \\mathbf { v } ^ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 682, + 506, + 698 + ], + "score": 1.0, + "content": ", and so", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 695, + 174, + 709 + ], + "spans": [ + { + "bbox": [ + 105, + 695, + 174, + 709 + ], + "score": 1.0, + "content": "on (see Fig. 1a).", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 46.5 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 708, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 708, + 126, + 722 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 126, + 710, + 133, + 720 + ], + "score": 0.77, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 708, + 284, + 722 + ], + "score": 1.0, + "content": "-predictron combines together many", + "type": "text" + }, + { + "bbox": [ + 285, + 711, + 291, + 720 + ], + "score": 0.85, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 291, + 708, + 505, + 722 + ], + "score": 1.0, + "content": "-step preturns. Specifically, it computes a diagonal", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 718, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 718, + 164, + 734 + ], + "score": 1.0, + "content": "weight matrix", + "type": "text" + }, + { + "bbox": [ + 164, + 720, + 176, + 730 + ], + "score": 0.87, + "content": "\\lambda ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 718, + 273, + 734 + ], + "score": 1.0, + "content": "from each internal state", + "type": "text" + }, + { + "bbox": [ + 273, + 720, + 284, + 730 + ], + "score": 0.87, + "content": "\\boldsymbol { \\bar { s } } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 718, + 410, + 734 + ], + "score": 1.0, + "content": ". The accumulator uses weights", + "type": "text" + }, + { + "bbox": [ + 411, + 720, + 452, + 732 + ], + "score": 0.93, + "content": "\\lambda ^ { 0 } , . . . , \\lambda ^ { K }", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 718, + 506, + 734 + ], + "score": 1.0, + "content": "to aggregate", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 48.5 + } + ], + "page_idx": 1, + "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, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "score": 1.0, + "content": "2", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "MRP as a recurrent core. The predictron unrolls this core multiple steps and accumulates rewards", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 239, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 239, + 105 + ], + "score": 1.0, + "content": "into an overall estimate of value.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 105, + 82, + 505, + 105 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 107, + 505, + 151 + ], + "lines": [ + { + "bbox": [ + 105, + 106, + 505, + 120 + ], + "spans": [ + { + "bbox": [ + 105, + 106, + 505, + 120 + ], + "score": 1.0, + "content": "We applied the predictron to procedurally generated random mazes, and a simulated pool domain,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 118, + 505, + 130 + ], + "spans": [ + { + "bbox": [ + 106, + 118, + 505, + 130 + ], + "score": 1.0, + "content": "directly from pixel inputs. In both cases, the predictron significantly outperformed model-free al-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 129, + 505, + 141 + ], + "spans": [ + { + "bbox": [ + 105, + 129, + 505, + 141 + ], + "score": 1.0, + "content": "gorithms with conventional deep network architectures; and was much more robust to architectural", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 141, + 196, + 152 + ], + "spans": [ + { + "bbox": [ + 106, + 141, + 196, + 152 + ], + "score": 1.0, + "content": "choices such as depth.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 106, + 505, + 152 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 165, + 200, + 178 + ], + "lines": [ + { + "bbox": [ + 104, + 163, + 202, + 181 + ], + "spans": [ + { + "bbox": [ + 104, + 163, + 202, + 181 + ], + "score": 1.0, + "content": "2 BACKGROUND", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 187, + 505, + 231 + ], + "lines": [ + { + "bbox": [ + 105, + 186, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 337, + 200 + ], + "score": 1.0, + "content": "We consider environments defined by an MRP with states", + "type": "text" + }, + { + "bbox": [ + 337, + 188, + 362, + 198 + ], + "score": 0.9, + "content": "s \\in S", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 186, + 505, + 200 + ], + "score": 1.0, + "content": ". The MRP is defined by a function,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 107, + 198, + 506, + 211 + ], + "spans": [ + { + "bbox": [ + 107, + 198, + 178, + 210 + ], + "score": 0.92, + "content": "s ^ { \\prime } , r , \\gamma = p ( s , \\alpha )", + "type": "inline_equation" + }, + { + "bbox": [ + 179, + 198, + 211, + 211 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 212, + 199, + 220, + 208 + ], + "score": 0.85, + "content": "s ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 221, + 198, + 292, + 211 + ], + "score": 1.0, + "content": "is the next state,", + "type": "text" + }, + { + "bbox": [ + 293, + 201, + 299, + 208 + ], + "score": 0.71, + "content": "r", + "type": "inline_equation" + }, + { + "bbox": [ + 299, + 198, + 377, + 211 + ], + "score": 1.0, + "content": "is the reward, and", + "type": "text" + }, + { + "bbox": [ + 377, + 200, + 385, + 210 + ], + "score": 0.83, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 198, + 506, + 211 + ], + "score": 1.0, + "content": "is the discount factor, which", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 210, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 505, + 223 + ], + "score": 1.0, + "content": "can for instance represent the non-termination probability for this transition. The process may be", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 221, + 227, + 233 + ], + "spans": [ + { + "bbox": [ + 106, + 221, + 214, + 233 + ], + "score": 1.0, + "content": "stochastic, given IID noise", + "type": "text" + }, + { + "bbox": [ + 215, + 222, + 222, + 230 + ], + "score": 0.71, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 223, + 221, + 227, + 233 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 186, + 506, + 233 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 234, + 505, + 300 + ], + "lines": [ + { + "bbox": [ + 106, + 233, + 504, + 248 + ], + "spans": [ + { + "bbox": [ + 106, + 233, + 450, + 248 + ], + "score": 1.0, + "content": "The return of an MRP is the cumulative discounted reward over a single trajectory,", + "type": "text" + }, + { + "bbox": [ + 450, + 236, + 504, + 246 + ], + "score": 0.88, + "content": "g _ { t } = r _ { t + 1 } +", + "type": "inline_equation" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 245, + 505, + 258 + ], + "spans": [ + { + "bbox": [ + 106, + 246, + 231, + 257 + ], + "score": 0.9, + "content": "\\gamma _ { t + 1 } r _ { t + 2 } + \\gamma _ { t + 1 } \\gamma _ { t + 2 } r _ { t + 3 } + \\ldots ,", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 245, + 259, + 258 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 260, + 247, + 270, + 257 + ], + "score": 0.86, + "content": "\\gamma _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 245, + 505, + 258 + ], + "score": 1.0, + "content": "can vary per time-step. We consider a generalisation of the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 257, + 505, + 268 + ], + "spans": [ + { + "bbox": [ + 106, + 257, + 303, + 268 + ], + "score": 1.0, + "content": "MRP setting that includes vector-valued rewards", + "type": "text" + }, + { + "bbox": [ + 304, + 258, + 310, + 266 + ], + "score": 0.27, + "content": "\\mathbf { r }", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 257, + 420, + 268 + ], + "score": 1.0, + "content": ", diagonal-matrix discounts", + "type": "text" + }, + { + "bbox": [ + 420, + 258, + 427, + 268 + ], + "score": 0.76, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 257, + 505, + 268 + ], + "score": 1.0, + "content": ", and vector-valued", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 267, + 505, + 280 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 136, + 280 + ], + "score": 1.0, + "content": "returns", + "type": "text" + }, + { + "bbox": [ + 137, + 269, + 144, + 279 + ], + "score": 0.3, + "content": "\\mathbf { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 267, + 505, + 280 + ], + "score": 1.0, + "content": "; definitions are otherwise identical to the above. We use this bold font notation to closely", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 278, + 505, + 291 + ], + "spans": [ + { + "bbox": [ + 105, + 278, + 505, + 291 + ], + "score": 1.0, + "content": "match the more familiar scalar MRP case; the majority of the paper can be comfortably understood", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 288, + 477, + 303 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 444, + 303 + ], + "score": 1.0, + "content": "by reading all rewards as scalars, and all discount factors as scalar and constant, i.e.,", + "type": "text" + }, + { + "bbox": [ + 444, + 291, + 473, + 301 + ], + "score": 0.89, + "content": "\\gamma _ { t } = \\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 288, + 477, + 303 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13.5, + "bbox_fs": [ + 105, + 233, + 505, + 303 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 303, + 504, + 347 + ], + "lines": [ + { + "bbox": [ + 105, + 302, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 233, + 316 + ], + "score": 1.0, + "content": "The value function of an MRP", + "type": "text" + }, + { + "bbox": [ + 234, + 304, + 241, + 314 + ], + "score": 0.78, + "content": "p", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 302, + 377, + 316 + ], + "score": 1.0, + "content": "is the expected return from state", + "type": "text" + }, + { + "bbox": [ + 377, + 306, + 383, + 313 + ], + "score": 0.44, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 302, + 388, + 316 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 388, + 302, + 488, + 315 + ], + "score": 0.89, + "content": "v _ { p } ( s ) = \\mathbb { E } _ { p } \\left[ \\mathbf { g } _ { t } \\mid s _ { t } = s \\right]", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 302, + 506, + 316 + ], + "score": 1.0, + "content": ". In", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 313, + 506, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 506, + 326 + ], + "score": 1.0, + "content": "the vector case, these are known as general value functions (Sutton et al., 2011). We will say that a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 205, + 338 + ], + "score": 1.0, + "content": "(general) value function", + "type": "text" + }, + { + "bbox": [ + 205, + 325, + 222, + 337 + ], + "score": 0.91, + "content": "v ( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 325, + 349, + 338 + ], + "score": 1.0, + "content": "is consistent with environment", + "type": "text" + }, + { + "bbox": [ + 349, + 327, + 356, + 336 + ], + "score": 0.83, + "content": "p", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 325, + 412, + 338 + ], + "score": 1.0, + "content": "if and only if", + "type": "text" + }, + { + "bbox": [ + 412, + 326, + 442, + 337 + ], + "score": 0.91, + "content": "v = v _ { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 442, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "which satisfies", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 335, + 306, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 306, + 348 + ], + "score": 1.0, + "content": "the following Bellman equation (Bellman, 1957),", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 18.5, + "bbox_fs": [ + 105, + 302, + 506, + 348 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 245, + 353, + 367, + 367 + ], + "lines": [ + { + "bbox": [ + 245, + 353, + 367, + 367 + ], + "spans": [ + { + "bbox": [ + 245, + 353, + 367, + 367 + ], + "score": 0.92, + "content": "v _ { p } ( s ) = \\mathbb { E } _ { p } \\left[ \\mathbf { r } + \\gamma v _ { p } ( s ^ { \\prime } ) \\mid s \\right] .", + "type": "interline_equation", + "image_path": "592d1d3e31a4ecdf1a1e4f2bf7665fd4a0cd742f9ccc0a118110105edca09678.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 245, + 353, + 367, + 367 + ], + "spans": [], + "index": 21 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 375, + 505, + 453 + ], + "lines": [ + { + "bbox": [ + 106, + 375, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 375, + 447, + 388 + ], + "score": 1.0, + "content": "In model-based reinforcement learning (Sutton and Barto, 1998), an approximation", + "type": "text" + }, + { + "bbox": [ + 447, + 378, + 478, + 387 + ], + "score": 0.87, + "content": "m \\approx p", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 375, + 505, + 388 + ], + "score": 1.0, + "content": "to the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 387, + 504, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 387, + 431, + 399 + ], + "score": 1.0, + "content": "environment is learned. In the uncontrolled setting this model is normally an MRP", + "type": "text" + }, + { + "bbox": [ + 432, + 387, + 504, + 398 + ], + "score": 0.83, + "content": "s ^ { \\prime } , \\mathbf { r } , \\gamma = m ( s , \\beta )", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 396, + 506, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 193, + 411 + ], + "score": 1.0, + "content": "that maps from state", + "type": "text" + }, + { + "bbox": [ + 193, + 400, + 199, + 407 + ], + "score": 0.69, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 200, + 396, + 281, + 411 + ], + "score": 1.0, + "content": "to subsequent state", + "type": "text" + }, + { + "bbox": [ + 281, + 398, + 290, + 407 + ], + "score": 0.85, + "content": "s ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 396, + 427, + 411 + ], + "score": 1.0, + "content": "and additionally outputs rewards", + "type": "text" + }, + { + "bbox": [ + 427, + 399, + 434, + 407 + ], + "score": 0.53, + "content": "\\mathbf { r }", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 396, + 493, + 411 + ], + "score": 1.0, + "content": "and discounts", + "type": "text" + }, + { + "bbox": [ + 493, + 400, + 501, + 409 + ], + "score": 0.76, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 396, + 506, + 411 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 409, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 106, + 409, + 345, + 421 + ], + "score": 1.0, + "content": "the model may be stochastic given an IID source of noise", + "type": "text" + }, + { + "bbox": [ + 345, + 409, + 353, + 420 + ], + "score": 0.83, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 353, + 409, + 469, + 421 + ], + "score": 1.0, + "content": ". A (general) value function", + "type": "text" + }, + { + "bbox": [ + 470, + 409, + 494, + 421 + ], + "score": 0.91, + "content": "v _ { m } ( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 494, + 409, + 506, + 421 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 419, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 106, + 419, + 199, + 431 + ], + "score": 1.0, + "content": "consistent with model", + "type": "text" + }, + { + "bbox": [ + 199, + 421, + 209, + 429 + ], + "score": 0.75, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 419, + 505, + 431 + ], + "score": 1.0, + "content": "(or valid, (Sutton, 1995)), if and only if it satisfies a Bellman equation", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 430, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 106, + 430, + 230, + 443 + ], + "score": 0.9, + "content": "v _ { m } ( s ) = \\mathbb { E } _ { m } \\left[ \\mathbf { r } + \\gamma v _ { m } ( s ^ { \\prime } ) \\mid s \\right]", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 430, + 320, + 443 + ], + "score": 1.0, + "content": "with respect to model", + "type": "text" + }, + { + "bbox": [ + 320, + 432, + 330, + 441 + ], + "score": 0.74, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 430, + 505, + 443 + ], + "score": 1.0, + "content": ". Conventionally, model-based RL methods", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 442, + 460, + 454 + ], + "spans": [ + { + "bbox": [ + 106, + 442, + 240, + 454 + ], + "score": 1.0, + "content": "focus on finding a value function", + "type": "text" + }, + { + "bbox": [ + 240, + 444, + 246, + 451 + ], + "score": 0.74, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 247, + 442, + 446, + 454 + ], + "score": 1.0, + "content": "that is consistent with a separately learned model", + "type": "text" + }, + { + "bbox": [ + 446, + 443, + 456, + 451 + ], + "score": 0.74, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 442, + 460, + 454 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 375, + 506, + 454 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 466, + 277, + 479 + ], + "lines": [ + { + "bbox": [ + 105, + 465, + 280, + 481 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 280, + 481 + ], + "score": 1.0, + "content": "3 PREDICTRON ARCHITECTURE", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 488, + 505, + 621 + ], + "lines": [ + { + "bbox": [ + 105, + 488, + 506, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 445, + 502 + ], + "score": 1.0, + "content": "The predictron is composed of four main components. First, a state representation", + "type": "text" + }, + { + "bbox": [ + 446, + 489, + 486, + 501 + ], + "score": 0.92, + "content": "\\mathbf { s } = f ( s )", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 488, + 506, + 502 + ], + "score": 1.0, + "content": "that", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 500, + 504, + 511 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 183, + 511 + ], + "score": 1.0, + "content": "encodes raw input", + "type": "text" + }, + { + "bbox": [ + 184, + 502, + 190, + 510 + ], + "score": 0.66, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 500, + 504, + 511 + ], + "score": 1.0, + "content": "(this could be a history of observations, in the partially observed setting, for", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 511, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 167, + 523 + ], + "score": 1.0, + "content": "example when", + "type": "text" + }, + { + "bbox": [ + 167, + 511, + 174, + 522 + ], + "score": 0.84, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 511, + 505, + 523 + ], + "score": 1.0, + "content": "is a recurrent network) into an internal (abstract, hidden) state s. Second, a model", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 522, + 506, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 522, + 180, + 533 + ], + "score": 0.91, + "content": "\\mathbf { s } ^ { \\prime } , \\mathbf { r } , \\gamma = m ( \\mathbf { s } , \\beta )", + "type": "inline_equation" + }, + { + "bbox": [ + 180, + 522, + 415, + 534 + ], + "score": 1.0, + "content": "that maps from internal state s to subsequent internal state", + "type": "text" + }, + { + "bbox": [ + 416, + 522, + 424, + 532 + ], + "score": 0.84, + "content": "\\mathbf { s } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 522, + 495, + 534 + ], + "score": 1.0, + "content": ", internal rewards", + "type": "text" + }, + { + "bbox": [ + 495, + 524, + 501, + 532 + ], + "score": 0.42, + "content": "\\mathbf { r }", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 522, + 506, + 534 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 532, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 195, + 546 + ], + "score": 1.0, + "content": "and internal discounts", + "type": "text" + }, + { + "bbox": [ + 195, + 534, + 202, + 545 + ], + "score": 0.8, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 532, + 298, + 546 + ], + "score": 1.0, + "content": ". Third, a value function", + "type": "text" + }, + { + "bbox": [ + 299, + 535, + 305, + 543 + ], + "score": 0.68, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 532, + 414, + 546 + ], + "score": 1.0, + "content": "that outputs internal values", + "type": "text" + }, + { + "bbox": [ + 414, + 533, + 452, + 545 + ], + "score": 0.92, + "content": "\\mathbf { v } = v ( \\mathbf { s } )", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 532, + 506, + 546 + ], + "score": 1.0, + "content": "representing", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 543, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 505, + 556 + ], + "score": 1.0, + "content": "the future, internal return from internal state s onwards. The predictron is applied by unrolling its", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 554, + 506, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 135, + 567 + ], + "score": 1.0, + "content": "model", + "type": "text" + }, + { + "bbox": [ + 135, + 556, + 146, + 565 + ], + "score": 0.75, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 554, + 506, + 567 + ], + "score": 1.0, + "content": "multiple “planning” steps to produce internal rewards, discounts and values. We use", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 565, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 156, + 578 + ], + "score": 1.0, + "content": "superscripts", + "type": "text" + }, + { + "bbox": [ + 156, + 565, + 168, + 576 + ], + "score": 0.85, + "content": "\\bullet ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 565, + 506, + 578 + ], + "score": 1.0, + "content": "to indicate internal steps of the model (which have no necessary connection to time", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 577, + 506, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 129, + 588 + ], + "score": 1.0, + "content": "steps", + "type": "text" + }, + { + "bbox": [ + 129, + 578, + 140, + 588 + ], + "score": 0.84, + "content": "\\bullet _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 577, + 506, + 588 + ], + "score": 1.0, + "content": "of the environment). Finally, these internal rewards, discounts and values are combined", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 587, + 506, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 506, + 600 + ], + "score": 1.0, + "content": "together by an accumulator into an overall estimate of value g. The whole predictron, from input", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 599, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 128, + 611 + ], + "score": 1.0, + "content": "state", + "type": "text" + }, + { + "bbox": [ + 128, + 601, + 134, + 608 + ], + "score": 0.73, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 135, + 599, + 505, + 611 + ], + "score": 1.0, + "content": "to output g, may be viewed as a value function approximator for external targets (i.e. the", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 609, + 460, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 309, + 622 + ], + "score": 1.0, + "content": "returns in the real environment). We consider both", + "type": "text" + }, + { + "bbox": [ + 310, + 610, + 317, + 619 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 609, + 354, + 622 + ], + "score": 1.0, + "content": "-step and", + "type": "text" + }, + { + "bbox": [ + 354, + 610, + 361, + 619 + ], + "score": 0.79, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 609, + 460, + 622 + ], + "score": 1.0, + "content": "-weighted accumulators.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 488, + 506, + 622 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 623, + 505, + 657 + ], + "lines": [ + { + "bbox": [ + 106, + 622, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 106, + 622, + 125, + 636 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 125, + 623, + 132, + 633 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 622, + 328, + 636 + ], + "score": 1.0, + "content": "-step predictron rolls its internal model forward", + "type": "text" + }, + { + "bbox": [ + 328, + 623, + 335, + 633 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 622, + 433, + 636 + ], + "score": 1.0, + "content": "steps. Specifically, the", + "type": "text" + }, + { + "bbox": [ + 433, + 623, + 440, + 633 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 440, + 622, + 505, + 636 + ], + "score": 1.0, + "content": "-step predictron", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 633, + 504, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 134, + 646 + ], + "score": 1.0, + "content": "return", + "type": "text" + }, + { + "bbox": [ + 135, + 634, + 147, + 646 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 147, + 633, + 497, + 646 + ], + "score": 1.0, + "content": "(henceforth abbreviated as preturn) is the internal return obtained by accumulating", + "type": "text" + }, + { + "bbox": [ + 497, + 635, + 504, + 644 + ], + "score": 0.77, + "content": "k", + "type": "inline_equation" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 644, + 316, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 228, + 658 + ], + "score": 1.0, + "content": "model steps, plus a final value", + "type": "text" + }, + { + "bbox": [ + 229, + 644, + 241, + 655 + ], + "score": 0.88, + "content": "\\mathbf { v } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 644, + 279, + 658 + ], + "score": 1.0, + "content": "from the", + "type": "text" + }, + { + "bbox": [ + 279, + 646, + 285, + 655 + ], + "score": 0.4, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 644, + 316, + 658 + ], + "score": 1.0, + "content": "th step,", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43, + "bbox_fs": [ + 105, + 622, + 505, + 658 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 182, + 662, + 428, + 678 + ], + "lines": [ + { + "bbox": [ + 182, + 662, + 428, + 678 + ], + "spans": [ + { + "bbox": [ + 182, + 662, + 428, + 678 + ], + "score": 0.9, + "content": "\\mathbf { g } ^ { k } = \\mathbf { r } ^ { 1 } + \\gamma ^ { 1 } ( \\mathbf { r } ^ { 2 } + \\gamma ^ { 2 } ( \\ldots ( \\mathbf { r } ^ { k - 1 } + \\gamma ^ { k - 1 } ( \\mathbf { r } ^ { k } + \\gamma ^ { k } \\mathbf { v } ^ { k } ) ) \\ldots ) ) .", + "type": "interline_equation", + "image_path": "3a50df1e4acdaaa18efc0491d17fa4c0272053b7e0b3186b85a705a0d0b8f4f4.jpg" + } + ] + } + ], + "index": 45, + "virtual_lines": [ + { + "bbox": [ + 182, + 662, + 428, + 678 + ], + "spans": [], + "index": 45 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 684, + 504, + 708 + ], + "lines": [ + { + "bbox": [ + 105, + 682, + 506, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 279, + 698 + ], + "score": 1.0, + "content": "The 0-step preturn is simply the first value", + "type": "text" + }, + { + "bbox": [ + 279, + 684, + 315, + 696 + ], + "score": 0.91, + "content": "\\mathbf { g } ^ { 0 } = \\mathbf { v } ^ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 682, + 405, + 698 + ], + "score": 1.0, + "content": ". The 1-step preturn is", + "type": "text" + }, + { + "bbox": [ + 405, + 684, + 473, + 696 + ], + "score": 0.92, + "content": "\\mathbf { g } ^ { 1 } = \\mathbf { r } ^ { 1 } + \\gamma ^ { 1 } \\mathbf { v } ^ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 682, + 506, + 698 + ], + "score": 1.0, + "content": ", and so", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 695, + 174, + 709 + ], + "spans": [ + { + "bbox": [ + 105, + 695, + 174, + 709 + ], + "score": 1.0, + "content": "on (see Fig. 1a).", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 46.5, + "bbox_fs": [ + 105, + 682, + 506, + 709 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 708, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 708, + 126, + 722 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 126, + 710, + 133, + 720 + ], + "score": 0.77, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 708, + 284, + 722 + ], + "score": 1.0, + "content": "-predictron combines together many", + "type": "text" + }, + { + "bbox": [ + 285, + 711, + 291, + 720 + ], + "score": 0.85, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 291, + 708, + 505, + 722 + ], + "score": 1.0, + "content": "-step preturns. Specifically, it computes a diagonal", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 718, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 718, + 164, + 734 + ], + "score": 1.0, + "content": "weight matrix", + "type": "text" + }, + { + "bbox": [ + 164, + 720, + 176, + 730 + ], + "score": 0.87, + "content": "\\lambda ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 718, + 273, + 734 + ], + "score": 1.0, + "content": "from each internal state", + "type": "text" + }, + { + "bbox": [ + 273, + 720, + 284, + 730 + ], + "score": 0.87, + "content": "\\boldsymbol { \\bar { s } } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 718, + 410, + 734 + ], + "score": 1.0, + "content": ". The accumulator uses weights", + "type": "text" + }, + { + "bbox": [ + 411, + 720, + 452, + 732 + ], + "score": 0.93, + "content": "\\lambda ^ { 0 } , . . . , \\lambda ^ { K }", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 718, + 506, + 734 + ], + "score": 1.0, + "content": "to aggregate", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 48.5, + "bbox_fs": [ + 105, + 708, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 109, + 58, + 510, + 242 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 58, + 510, + 242 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 58, + 510, + 242 + ], + "spans": [ + { + "bbox": [ + 109, + 58, + 510, + 242 + ], + "score": 0.968, + "type": "image", + "image_path": "6f6c0ac1ea5dd3b78bbf370494686c721ff710971f39d404ac4fa8e2eec69c6a.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 109, + 58, + 510, + 119.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 109, + 119.33333333333334, + 510, + 180.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 109, + 180.66666666666669, + 510, + 242.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 252, + 506, + 352 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 250, + 506, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 181, + 266 + ], + "score": 1.0, + "content": "Figure 1: a) The", + "type": "text" + }, + { + "bbox": [ + 181, + 253, + 188, + 262 + ], + "score": 0.82, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 250, + 506, + 266 + ], + "score": 1.0, + "content": "-step predictron architecture. The first three columns illustrate 0, 1 and 2-step", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 263, + 506, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 506, + 277 + ], + "score": 1.0, + "content": "pathways through the predictron. The 0-step preturn reduces to standard model-free value function", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 273, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 505, + 288 + ], + "score": 1.0, + "content": "approximation; other preturns “imagine” additional steps with an internal model. Each pathway", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 284, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 144, + 299 + ], + "score": 1.0, + "content": "outputs a", + "type": "text" + }, + { + "bbox": [ + 144, + 286, + 151, + 295 + ], + "score": 0.82, + "content": "k \\mathrm { . }", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 284, + 201, + 299 + ], + "score": 1.0, + "content": "-step preturn", + "type": "text" + }, + { + "bbox": [ + 202, + 285, + 214, + 297 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 284, + 505, + 299 + ], + "score": 1.0, + "content": "that accumulates discounted rewards along with a final value estimate. In", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 296, + 505, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 153, + 309 + ], + "score": 1.0, + "content": "practice all", + "type": "text" + }, + { + "bbox": [ + 153, + 297, + 160, + 306 + ], + "score": 0.83, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 296, + 400, + 309 + ], + "score": 1.0, + "content": "-step preturns are computed in a single forward pass. b) The", + "type": "text" + }, + { + "bbox": [ + 401, + 297, + 407, + 307 + ], + "score": 0.8, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 296, + 505, + 309 + ], + "score": 1.0, + "content": "-predictron architecture.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 307, + 505, + 320 + ], + "spans": [ + { + "bbox": [ + 106, + 307, + 124, + 320 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 124, + 308, + 131, + 317 + ], + "score": 0.79, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 307, + 384, + 320 + ], + "score": 1.0, + "content": "-parameters gate between the different preturns. The output is a", + "type": "text" + }, + { + "bbox": [ + 385, + 308, + 392, + 317 + ], + "score": 0.76, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 307, + 424, + 320 + ], + "score": 1.0, + "content": "-preturn", + "type": "text" + }, + { + "bbox": [ + 425, + 307, + 437, + 318 + ], + "score": 0.88, + "content": "\\mathbf { g } ^ { \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 307, + 505, + 320 + ], + "score": 1.0, + "content": "that is a mixture", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 104, + 316, + 505, + 332 + ], + "spans": [ + { + "bbox": [ + 104, + 316, + 140, + 332 + ], + "score": 1.0, + "content": "over the", + "type": "text" + }, + { + "bbox": [ + 140, + 319, + 147, + 328 + ], + "score": 0.83, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 147, + 316, + 267, + 332 + ], + "score": 1.0, + "content": "-step preturns. For example, if", + "type": "text" + }, + { + "bbox": [ + 267, + 317, + 365, + 330 + ], + "score": 0.91, + "content": "\\pmb { \\lambda } ^ { 0 } = \\mathbf { 1 } , \\pmb { \\lambda } ^ { 1 } = \\mathbf { 1 } , \\pmb { \\lambda } ^ { 2 } = \\mathbf { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 316, + 505, + 332 + ], + "score": 1.0, + "content": "then we recover the 2-step preturn,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 327, + 506, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 328, + 144, + 341 + ], + "score": 0.91, + "content": "\\mathbf { g } ^ { \\lambda } = \\mathbf { g } ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 327, + 218, + 343 + ], + "score": 1.0, + "content": ". Discount factors", + "type": "text" + }, + { + "bbox": [ + 219, + 329, + 231, + 341 + ], + "score": 0.9, + "content": "\\gamma ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 327, + 250, + 343 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 250, + 330, + 257, + 339 + ], + "score": 0.8, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 327, + 306, + 343 + ], + "score": 1.0, + "content": "-parameters", + "type": "text" + }, + { + "bbox": [ + 306, + 329, + 318, + 339 + ], + "score": 0.85, + "content": "\\lambda ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 318, + 327, + 412, + 343 + ], + "score": 1.0, + "content": "are dependent on state", + "type": "text" + }, + { + "bbox": [ + 413, + 329, + 424, + 339 + ], + "score": 0.86, + "content": "\\mathbf { s } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 327, + 506, + 343 + ], + "score": 1.0, + "content": "; this dependence is", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 340, + 203, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 203, + 353 + ], + "score": 1.0, + "content": "not shown in the figure.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 7 + } + ], + "index": 4.0 + }, + { + "type": "text", + "bbox": [ + 104, + 370, + 470, + 383 + ], + "lines": [ + { + "bbox": [ + 104, + 368, + 471, + 385 + ], + "spans": [ + { + "bbox": [ + 104, + 368, + 126, + 385 + ], + "score": 1.0, + "content": "over", + "type": "text" + }, + { + "bbox": [ + 127, + 371, + 133, + 381 + ], + "score": 0.82, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 368, + 189, + 385 + ], + "score": 1.0, + "content": "-step preturns", + "type": "text" + }, + { + "bbox": [ + 189, + 370, + 231, + 383 + ], + "score": 0.93, + "content": "\\mathbf { g } ^ { 0 } , . . . , \\mathbf { g } ^ { K }", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 368, + 413, + 385 + ], + "score": 1.0, + "content": "and output a combined value that we call the", + "type": "text" + }, + { + "bbox": [ + 413, + 371, + 420, + 381 + ], + "score": 0.68, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 420, + 368, + 453, + 385 + ], + "score": 1.0, + "content": "-preturn", + "type": "text" + }, + { + "bbox": [ + 454, + 370, + 466, + 383 + ], + "score": 0.87, + "content": "\\mathbf { g } ^ { \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 368, + 471, + 385 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "interline_equation", + "bbox": [ + 141, + 385, + 466, + 432 + ], + "lines": [ + { + "bbox": [ + 141, + 385, + 466, + 432 + ], + "spans": [ + { + "bbox": [ + 141, + 385, + 466, + 432 + ], + "score": 0.93, + "content": "\\mathbf { g } ^ { \\lambda } = \\sum _ { k = 0 } ^ { K } w ^ { k } \\mathbf { g } ^ { k } \\qquad \\mathrm { w h e r e } \\qquad w ^ { k } = \\left\\{ \\begin{array} { l l } { ( 1 - \\lambda ^ { k } ) \\prod _ { j = 0 } ^ { k - 1 } \\lambda ^ { j } } & { \\mathrm { i f ~ } k < K } \\\\ { \\qquad } \\\\ { \\prod _ { j = 0 } ^ { K - 1 } \\lambda ^ { j } } & { \\mathrm { o t h e r w i s e . } } \\end{array} \\right.", + "type": "interline_equation", + "image_path": "349f1e8d5535c720c97c4daf1653bc4cef214c958e36bf810ab5162246522f2f.jpg" + } + ] + } + ], + "index": 14, + "virtual_lines": [ + { + "bbox": [ + 141, + 385, + 466, + 400.6666666666667 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 141, + 400.6666666666667, + 466, + 416.33333333333337 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 141, + 416.33333333333337, + 466, + 432.00000000000006 + ], + "spans": [], + "index": 15 + } + ] + }, + { + "type": "text", + "bbox": [ + 109, + 435, + 502, + 469 + ], + "lines": [ + { + "bbox": [ + 107, + 435, + 504, + 447 + ], + "spans": [ + { + "bbox": [ + 107, + 435, + 261, + 447 + ], + "score": 1.0, + "content": "where 1 is the identity matrix. This", + "type": "text" + }, + { + "bbox": [ + 261, + 435, + 268, + 445 + ], + "score": 0.79, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 435, + 384, + 447 + ], + "score": 1.0, + "content": "-preturn is analogous to the", + "type": "text" + }, + { + "bbox": [ + 385, + 435, + 392, + 445 + ], + "score": 0.8, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 435, + 504, + 447 + ], + "score": 1.0, + "content": "-return in the forward-view", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 446, + 504, + 458 + ], + "spans": [ + { + "bbox": [ + 106, + 446, + 134, + 457 + ], + "score": 0.77, + "content": "\\mathrm { T D } ( \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 134, + 446, + 504, + 458 + ], + "score": 1.0, + "content": "algorithm (Sutton, 1988; Sutton and Barto, 1998). It may also be computed by a backward", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 455, + 295, + 471 + ], + "spans": [ + { + "bbox": [ + 104, + 455, + 270, + 471 + ], + "score": 1.0, + "content": "accumulation through intermediate steps", + "type": "text" + }, + { + "bbox": [ + 271, + 456, + 289, + 469 + ], + "score": 0.9, + "content": "\\mathbf { g } ^ { k , \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 455, + 295, + 471 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17 + }, + { + "type": "interline_equation", + "bbox": [ + 204, + 471, + 406, + 488 + ], + "lines": [ + { + "bbox": [ + 204, + 471, + 406, + 488 + ], + "spans": [ + { + "bbox": [ + 204, + 471, + 406, + 488 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { k , \\lambda } = ( \\mathbf { 1 } - \\lambda ^ { k } ) \\mathbf { v } ^ { k } + \\lambda ^ { k } \\left( \\mathbf { r } ^ { k + 1 } + \\gamma ^ { k + 1 } \\mathbf { g } ^ { k + 1 , \\lambda } \\right) ,", + "type": "interline_equation", + "image_path": "3bcf3f07b5596719b14bfb35b0fae8902269d7bcf989870314babc28e4648e57.jpg" + } + ] + } + ], + "index": 19, + "virtual_lines": [ + { + "bbox": [ + 204, + 471, + 406, + 488 + ], + "spans": [], + "index": 19 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 491, + 505, + 581 + ], + "lines": [ + { + "bbox": [ + 105, + 489, + 506, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 133, + 507 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 491, + 181, + 504 + ], + "score": 0.92, + "content": "\\mathbf { g } ^ { K , \\lambda } = \\mathbf { v } ^ { K }", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 489, + 244, + 507 + ], + "score": 1.0, + "content": ", and then using", + "type": "text" + }, + { + "bbox": [ + 245, + 491, + 288, + 504 + ], + "score": 0.92, + "content": "\\mathbf { g } ^ { \\lambda } = \\mathbf { g } ^ { 0 , \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 489, + 371, + 507 + ], + "score": 1.0, + "content": ". Computation in the", + "type": "text" + }, + { + "bbox": [ + 371, + 493, + 378, + 502 + ], + "score": 0.78, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 378, + 489, + 506, + 507 + ], + "score": 1.0, + "content": "-predictron operates in a sweep,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 504, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 106, + 504, + 264, + 515 + ], + "score": 1.0, + "content": "iterating first through the model from", + "type": "text" + }, + { + "bbox": [ + 264, + 504, + 317, + 514 + ], + "score": 0.91, + "content": "k = 0 \\ldots K", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 504, + 505, + 515 + ], + "score": 1.0, + "content": "and then back through the accumulator from", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 514, + 506, + 527 + ], + "spans": [ + { + "bbox": [ + 106, + 515, + 158, + 525 + ], + "score": 0.9, + "content": "k = K \\ldots 0", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 514, + 423, + 527 + ], + "score": 1.0, + "content": "in a single “forward” pass of the network (see Figure 1b). Each", + "type": "text" + }, + { + "bbox": [ + 424, + 514, + 436, + 525 + ], + "score": 0.88, + "content": "\\lambda ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 436, + 514, + 506, + 527 + ], + "score": 1.0, + "content": "weight acts as a", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 525, + 506, + 538 + ], + "spans": [ + { + "bbox": [ + 104, + 525, + 232, + 538 + ], + "score": 1.0, + "content": "gate on the computation of the", + "type": "text" + }, + { + "bbox": [ + 232, + 526, + 239, + 536 + ], + "score": 0.8, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 240, + 525, + 319, + 538 + ], + "score": 1.0, + "content": "-preturn: a value of", + "type": "text" + }, + { + "bbox": [ + 319, + 525, + 352, + 536 + ], + "score": 0.92, + "content": "\\lambda ^ { k } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 352, + 525, + 421, + 538 + ], + "score": 1.0, + "content": "will truncate the", + "type": "text" + }, + { + "bbox": [ + 421, + 526, + 428, + 536 + ], + "score": 0.79, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 525, + 494, + 538 + ], + "score": 1.0, + "content": "-preturn at layer", + "type": "text" + }, + { + "bbox": [ + 495, + 526, + 501, + 536 + ], + "score": 0.77, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 525, + 506, + 538 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 535, + 506, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 535, + 171, + 549 + ], + "score": 1.0, + "content": "while a value of", + "type": "text" + }, + { + "bbox": [ + 172, + 536, + 203, + 546 + ], + "score": 0.91, + "content": "\\mathbf { \\hat { \\lambda } } \\mathbf { \\lambda } ^ { k } = \\mathbf { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 535, + 456, + 549 + ], + "score": 1.0, + "content": "will utilise deeper layers based on additional steps of the model", + "type": "text" + }, + { + "bbox": [ + 457, + 538, + 466, + 547 + ], + "score": 0.74, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 467, + 535, + 506, + 549 + ], + "score": 1.0, + "content": "; the final", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 546, + 506, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 177, + 561 + ], + "score": 1.0, + "content": "weight is always", + "type": "text" + }, + { + "bbox": [ + 177, + 547, + 214, + 558 + ], + "score": 0.9, + "content": "\\pmb { \\lambda } ^ { K } = \\mathbf { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 546, + 282, + 561 + ], + "score": 1.0, + "content": ". The individual", + "type": "text" + }, + { + "bbox": [ + 282, + 547, + 294, + 558 + ], + "score": 0.88, + "content": "\\dot { \\lambda } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 546, + 506, + 561 + ], + "score": 1.0, + "content": "weights may depend on the corresponding abstract", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 557, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 557, + 127, + 571 + ], + "score": 1.0, + "content": "state", + "type": "text" + }, + { + "bbox": [ + 127, + 558, + 138, + 568 + ], + "score": 0.87, + "content": "\\mathbf { s } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 557, + 505, + 571 + ], + "score": 1.0, + "content": "and can differ per prediction. This enables the predictron to compute to an adaptive depth", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 569, + 448, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 569, + 448, + 582 + ], + "score": 1.0, + "content": "(Graves, 2016) depending on the internal state and learning dynamics of the network.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 23.5 + }, + { + "type": "title", + "bbox": [ + 107, + 593, + 302, + 606 + ], + "lines": [ + { + "bbox": [ + 105, + 592, + 303, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 303, + 608 + ], + "score": 1.0, + "content": "4 PREDICTRON LEARNING UPDATES", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 106, + 614, + 505, + 659 + ], + "lines": [ + { + "bbox": [ + 106, + 614, + 506, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 614, + 343, + 628 + ], + "score": 1.0, + "content": "We first consider updates that optimise the joint parameters", + "type": "text" + }, + { + "bbox": [ + 344, + 615, + 351, + 625 + ], + "score": 0.81, + "content": "\\pmb { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 614, + 506, + 628 + ], + "score": 1.0, + "content": "of the state representation, model, and", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 626, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 248, + 639 + ], + "score": 1.0, + "content": "value function. We begin with the", + "type": "text" + }, + { + "bbox": [ + 249, + 627, + 255, + 636 + ], + "score": 0.82, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 626, + 385, + 639 + ], + "score": 1.0, + "content": "-step predictron. We update the", + "type": "text" + }, + { + "bbox": [ + 385, + 627, + 392, + 636 + ], + "score": 0.82, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 626, + 457, + 639 + ], + "score": 1.0, + "content": "-step predictron", + "type": "text" + }, + { + "bbox": [ + 457, + 626, + 469, + 637 + ], + "score": 0.9, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 626, + 505, + 639 + ], + "score": 1.0, + "content": "towards", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 636, + 506, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 177, + 650 + ], + "score": 1.0, + "content": "a target outcome", + "type": "text" + }, + { + "bbox": [ + 178, + 639, + 186, + 649 + ], + "score": 0.63, + "content": "\\mathbf { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 636, + 506, + 650 + ], + "score": 1.0, + "content": ", such as the Monte-Carlo return from the real environment, by minimising a", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 649, + 208, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 208, + 660 + ], + "score": 1.0, + "content": "mean-squared error loss,", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30.5 + }, + { + "type": "interline_equation", + "bbox": [ + 141, + 662, + 468, + 690 + ], + "lines": [ + { + "bbox": [ + 141, + 662, + 468, + 690 + ], + "spans": [ + { + "bbox": [ + 141, + 662, + 468, + 690 + ], + "score": 0.89, + "content": "L ^ { k } = { \\frac { 1 } { 2 } } \\left\\| \\mathbb { E } _ { p } \\left[ \\mathbf { g } \\mid s \\right] - \\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { k } \\mid s \\right] \\right\\| ^ { 2 } . \\qquad { \\frac { \\partial l ^ { k } } { \\partial \\theta } } = \\left( \\mathbf { g } - \\mathbf { g } ^ { k } \\right) { \\frac { \\partial \\mathbf { g } ^ { k } } { \\partial \\theta } } .", + "type": "interline_equation", + "image_path": "351eac7a2de69730f3dab1f5189c90d52d764ae134a2439b606e7ef12358b6b9.jpg" + } + ] + } + ], + "index": 33, + "virtual_lines": [ + { + "bbox": [ + 141, + 662, + 468, + 690 + ], + "spans": [], + "index": 33 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 693, + 505, + 733 + ], + "lines": [ + { + "bbox": [ + 106, + 692, + 506, + 709 + ], + "spans": [ + { + "bbox": [ + 106, + 693, + 134, + 709 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 692, + 210, + 709 + ], + "score": 0.93, + "content": "l ^ { k } = \\textstyle { \\frac { 1 } { 2 } } \\left\\| \\mathbf { g } - \\mathbf { g } ^ { k } \\right\\| ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 693, + 506, + 709 + ], + "score": 1.0, + "content": "is the sample loss. We can use the gradient of the sample loss to update", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 705, + 505, + 720 + ], + "spans": [ + { + "bbox": [ + 105, + 705, + 505, + 720 + ], + "score": 1.0, + "content": "parameters, e.g. by stochastic gradient descent. For stochastic models, two independent samples are", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 716, + 394, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 718, + 156, + 734 + ], + "score": 1.0, + "content": "required for", + "type": "text" + }, + { + "bbox": [ + 156, + 719, + 168, + 732 + ], + "score": 0.87, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 718, + 187, + 734 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 184, + 716, + 206, + 730 + ], + "score": 1.0, + "content": "∂ g k", + "type": "text" + }, + { + "bbox": [ + 204, + 718, + 377, + 734 + ], + "score": 1.0, + "content": "to get unbiased samples for the gradient of", + "type": "text" + }, + { + "bbox": [ + 378, + 721, + 389, + 730 + ], + "score": 0.88, + "content": "L ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 718, + 394, + 734 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "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" + } + ] + } + ] + }, + { + "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" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 109, + 58, + 510, + 242 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 58, + 510, + 242 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 58, + 510, + 242 + ], + "spans": [ + { + "bbox": [ + 109, + 58, + 510, + 242 + ], + "score": 0.968, + "type": "image", + "image_path": "6f6c0ac1ea5dd3b78bbf370494686c721ff710971f39d404ac4fa8e2eec69c6a.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 109, + 58, + 510, + 119.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 109, + 119.33333333333334, + 510, + 180.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 109, + 180.66666666666669, + 510, + 242.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 252, + 506, + 352 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 250, + 506, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 181, + 266 + ], + "score": 1.0, + "content": "Figure 1: a) The", + "type": "text" + }, + { + "bbox": [ + 181, + 253, + 188, + 262 + ], + "score": 0.82, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 250, + 506, + 266 + ], + "score": 1.0, + "content": "-step predictron architecture. The first three columns illustrate 0, 1 and 2-step", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 263, + 506, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 506, + 277 + ], + "score": 1.0, + "content": "pathways through the predictron. The 0-step preturn reduces to standard model-free value function", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 273, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 505, + 288 + ], + "score": 1.0, + "content": "approximation; other preturns “imagine” additional steps with an internal model. Each pathway", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 284, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 144, + 299 + ], + "score": 1.0, + "content": "outputs a", + "type": "text" + }, + { + "bbox": [ + 144, + 286, + 151, + 295 + ], + "score": 0.82, + "content": "k \\mathrm { . }", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 284, + 201, + 299 + ], + "score": 1.0, + "content": "-step preturn", + "type": "text" + }, + { + "bbox": [ + 202, + 285, + 214, + 297 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 284, + 505, + 299 + ], + "score": 1.0, + "content": "that accumulates discounted rewards along with a final value estimate. In", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 296, + 505, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 153, + 309 + ], + "score": 1.0, + "content": "practice all", + "type": "text" + }, + { + "bbox": [ + 153, + 297, + 160, + 306 + ], + "score": 0.83, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 296, + 400, + 309 + ], + "score": 1.0, + "content": "-step preturns are computed in a single forward pass. b) The", + "type": "text" + }, + { + "bbox": [ + 401, + 297, + 407, + 307 + ], + "score": 0.8, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 296, + 505, + 309 + ], + "score": 1.0, + "content": "-predictron architecture.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 307, + 505, + 320 + ], + "spans": [ + { + "bbox": [ + 106, + 307, + 124, + 320 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 124, + 308, + 131, + 317 + ], + "score": 0.79, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 307, + 384, + 320 + ], + "score": 1.0, + "content": "-parameters gate between the different preturns. The output is a", + "type": "text" + }, + { + "bbox": [ + 385, + 308, + 392, + 317 + ], + "score": 0.76, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 307, + 424, + 320 + ], + "score": 1.0, + "content": "-preturn", + "type": "text" + }, + { + "bbox": [ + 425, + 307, + 437, + 318 + ], + "score": 0.88, + "content": "\\mathbf { g } ^ { \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 307, + 505, + 320 + ], + "score": 1.0, + "content": "that is a mixture", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 104, + 316, + 505, + 332 + ], + "spans": [ + { + "bbox": [ + 104, + 316, + 140, + 332 + ], + "score": 1.0, + "content": "over the", + "type": "text" + }, + { + "bbox": [ + 140, + 319, + 147, + 328 + ], + "score": 0.83, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 147, + 316, + 267, + 332 + ], + "score": 1.0, + "content": "-step preturns. For example, if", + "type": "text" + }, + { + "bbox": [ + 267, + 317, + 365, + 330 + ], + "score": 0.91, + "content": "\\pmb { \\lambda } ^ { 0 } = \\mathbf { 1 } , \\pmb { \\lambda } ^ { 1 } = \\mathbf { 1 } , \\pmb { \\lambda } ^ { 2 } = \\mathbf { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 316, + 505, + 332 + ], + "score": 1.0, + "content": "then we recover the 2-step preturn,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 327, + 506, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 328, + 144, + 341 + ], + "score": 0.91, + "content": "\\mathbf { g } ^ { \\lambda } = \\mathbf { g } ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 327, + 218, + 343 + ], + "score": 1.0, + "content": ". Discount factors", + "type": "text" + }, + { + "bbox": [ + 219, + 329, + 231, + 341 + ], + "score": 0.9, + "content": "\\gamma ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 327, + 250, + 343 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 250, + 330, + 257, + 339 + ], + "score": 0.8, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 327, + 306, + 343 + ], + "score": 1.0, + "content": "-parameters", + "type": "text" + }, + { + "bbox": [ + 306, + 329, + 318, + 339 + ], + "score": 0.85, + "content": "\\lambda ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 318, + 327, + 412, + 343 + ], + "score": 1.0, + "content": "are dependent on state", + "type": "text" + }, + { + "bbox": [ + 413, + 329, + 424, + 339 + ], + "score": 0.86, + "content": "\\mathbf { s } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 327, + 506, + 343 + ], + "score": 1.0, + "content": "; this dependence is", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 340, + 203, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 203, + 353 + ], + "score": 1.0, + "content": "not shown in the figure.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 7 + } + ], + "index": 4.0 + }, + { + "type": "text", + "bbox": [ + 104, + 370, + 470, + 383 + ], + "lines": [ + { + "bbox": [ + 104, + 368, + 471, + 385 + ], + "spans": [ + { + "bbox": [ + 104, + 368, + 126, + 385 + ], + "score": 1.0, + "content": "over", + "type": "text" + }, + { + "bbox": [ + 127, + 371, + 133, + 381 + ], + "score": 0.82, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 368, + 189, + 385 + ], + "score": 1.0, + "content": "-step preturns", + "type": "text" + }, + { + "bbox": [ + 189, + 370, + 231, + 383 + ], + "score": 0.93, + "content": "\\mathbf { g } ^ { 0 } , . . . , \\mathbf { g } ^ { K }", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 368, + 413, + 385 + ], + "score": 1.0, + "content": "and output a combined value that we call the", + "type": "text" + }, + { + "bbox": [ + 413, + 371, + 420, + 381 + ], + "score": 0.68, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 420, + 368, + 453, + 385 + ], + "score": 1.0, + "content": "-preturn", + "type": "text" + }, + { + "bbox": [ + 454, + 370, + 466, + 383 + ], + "score": 0.87, + "content": "\\mathbf { g } ^ { \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 368, + 471, + 385 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12, + "bbox_fs": [ + 104, + 368, + 471, + 385 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 141, + 385, + 466, + 432 + ], + "lines": [ + { + "bbox": [ + 141, + 385, + 466, + 432 + ], + "spans": [ + { + "bbox": [ + 141, + 385, + 466, + 432 + ], + "score": 0.93, + "content": "\\mathbf { g } ^ { \\lambda } = \\sum _ { k = 0 } ^ { K } w ^ { k } \\mathbf { g } ^ { k } \\qquad \\mathrm { w h e r e } \\qquad w ^ { k } = \\left\\{ \\begin{array} { l l } { ( 1 - \\lambda ^ { k } ) \\prod _ { j = 0 } ^ { k - 1 } \\lambda ^ { j } } & { \\mathrm { i f ~ } k < K } \\\\ { \\qquad } \\\\ { \\prod _ { j = 0 } ^ { K - 1 } \\lambda ^ { j } } & { \\mathrm { o t h e r w i s e . } } \\end{array} \\right.", + "type": "interline_equation", + "image_path": "349f1e8d5535c720c97c4daf1653bc4cef214c958e36bf810ab5162246522f2f.jpg" + } + ] + } + ], + "index": 14, + "virtual_lines": [ + { + "bbox": [ + 141, + 385, + 466, + 400.6666666666667 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 141, + 400.6666666666667, + 466, + 416.33333333333337 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 141, + 416.33333333333337, + 466, + 432.00000000000006 + ], + "spans": [], + "index": 15 + } + ] + }, + { + "type": "text", + "bbox": [ + 109, + 435, + 502, + 469 + ], + "lines": [ + { + "bbox": [ + 107, + 435, + 504, + 447 + ], + "spans": [ + { + "bbox": [ + 107, + 435, + 261, + 447 + ], + "score": 1.0, + "content": "where 1 is the identity matrix. This", + "type": "text" + }, + { + "bbox": [ + 261, + 435, + 268, + 445 + ], + "score": 0.79, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 435, + 384, + 447 + ], + "score": 1.0, + "content": "-preturn is analogous to the", + "type": "text" + }, + { + "bbox": [ + 385, + 435, + 392, + 445 + ], + "score": 0.8, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 435, + 504, + 447 + ], + "score": 1.0, + "content": "-return in the forward-view", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 446, + 504, + 458 + ], + "spans": [ + { + "bbox": [ + 106, + 446, + 134, + 457 + ], + "score": 0.77, + "content": "\\mathrm { T D } ( \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 134, + 446, + 504, + 458 + ], + "score": 1.0, + "content": "algorithm (Sutton, 1988; Sutton and Barto, 1998). It may also be computed by a backward", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 455, + 295, + 471 + ], + "spans": [ + { + "bbox": [ + 104, + 455, + 270, + 471 + ], + "score": 1.0, + "content": "accumulation through intermediate steps", + "type": "text" + }, + { + "bbox": [ + 271, + 456, + 289, + 469 + ], + "score": 0.9, + "content": "\\mathbf { g } ^ { k , \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 455, + 295, + 471 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17, + "bbox_fs": [ + 104, + 435, + 504, + 471 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 204, + 471, + 406, + 488 + ], + "lines": [ + { + "bbox": [ + 204, + 471, + 406, + 488 + ], + "spans": [ + { + "bbox": [ + 204, + 471, + 406, + 488 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { k , \\lambda } = ( \\mathbf { 1 } - \\lambda ^ { k } ) \\mathbf { v } ^ { k } + \\lambda ^ { k } \\left( \\mathbf { r } ^ { k + 1 } + \\gamma ^ { k + 1 } \\mathbf { g } ^ { k + 1 , \\lambda } \\right) ,", + "type": "interline_equation", + "image_path": "3bcf3f07b5596719b14bfb35b0fae8902269d7bcf989870314babc28e4648e57.jpg" + } + ] + } + ], + "index": 19, + "virtual_lines": [ + { + "bbox": [ + 204, + 471, + 406, + 488 + ], + "spans": [], + "index": 19 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 491, + 505, + 581 + ], + "lines": [ + { + "bbox": [ + 105, + 489, + 506, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 133, + 507 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 491, + 181, + 504 + ], + "score": 0.92, + "content": "\\mathbf { g } ^ { K , \\lambda } = \\mathbf { v } ^ { K }", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 489, + 244, + 507 + ], + "score": 1.0, + "content": ", and then using", + "type": "text" + }, + { + "bbox": [ + 245, + 491, + 288, + 504 + ], + "score": 0.92, + "content": "\\mathbf { g } ^ { \\lambda } = \\mathbf { g } ^ { 0 , \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 489, + 371, + 507 + ], + "score": 1.0, + "content": ". Computation in the", + "type": "text" + }, + { + "bbox": [ + 371, + 493, + 378, + 502 + ], + "score": 0.78, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 378, + 489, + 506, + 507 + ], + "score": 1.0, + "content": "-predictron operates in a sweep,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 504, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 106, + 504, + 264, + 515 + ], + "score": 1.0, + "content": "iterating first through the model from", + "type": "text" + }, + { + "bbox": [ + 264, + 504, + 317, + 514 + ], + "score": 0.91, + "content": "k = 0 \\ldots K", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 504, + 505, + 515 + ], + "score": 1.0, + "content": "and then back through the accumulator from", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 514, + 506, + 527 + ], + "spans": [ + { + "bbox": [ + 106, + 515, + 158, + 525 + ], + "score": 0.9, + "content": "k = K \\ldots 0", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 514, + 423, + 527 + ], + "score": 1.0, + "content": "in a single “forward” pass of the network (see Figure 1b). Each", + "type": "text" + }, + { + "bbox": [ + 424, + 514, + 436, + 525 + ], + "score": 0.88, + "content": "\\lambda ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 436, + 514, + 506, + 527 + ], + "score": 1.0, + "content": "weight acts as a", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 525, + 506, + 538 + ], + "spans": [ + { + "bbox": [ + 104, + 525, + 232, + 538 + ], + "score": 1.0, + "content": "gate on the computation of the", + "type": "text" + }, + { + "bbox": [ + 232, + 526, + 239, + 536 + ], + "score": 0.8, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 240, + 525, + 319, + 538 + ], + "score": 1.0, + "content": "-preturn: a value of", + "type": "text" + }, + { + "bbox": [ + 319, + 525, + 352, + 536 + ], + "score": 0.92, + "content": "\\lambda ^ { k } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 352, + 525, + 421, + 538 + ], + "score": 1.0, + "content": "will truncate the", + "type": "text" + }, + { + "bbox": [ + 421, + 526, + 428, + 536 + ], + "score": 0.79, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 525, + 494, + 538 + ], + "score": 1.0, + "content": "-preturn at layer", + "type": "text" + }, + { + "bbox": [ + 495, + 526, + 501, + 536 + ], + "score": 0.77, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 525, + 506, + 538 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 535, + 506, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 535, + 171, + 549 + ], + "score": 1.0, + "content": "while a value of", + "type": "text" + }, + { + "bbox": [ + 172, + 536, + 203, + 546 + ], + "score": 0.91, + "content": "\\mathbf { \\hat { \\lambda } } \\mathbf { \\lambda } ^ { k } = \\mathbf { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 535, + 456, + 549 + ], + "score": 1.0, + "content": "will utilise deeper layers based on additional steps of the model", + "type": "text" + }, + { + "bbox": [ + 457, + 538, + 466, + 547 + ], + "score": 0.74, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 467, + 535, + 506, + 549 + ], + "score": 1.0, + "content": "; the final", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 546, + 506, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 177, + 561 + ], + "score": 1.0, + "content": "weight is always", + "type": "text" + }, + { + "bbox": [ + 177, + 547, + 214, + 558 + ], + "score": 0.9, + "content": "\\pmb { \\lambda } ^ { K } = \\mathbf { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 546, + 282, + 561 + ], + "score": 1.0, + "content": ". The individual", + "type": "text" + }, + { + "bbox": [ + 282, + 547, + 294, + 558 + ], + "score": 0.88, + "content": "\\dot { \\lambda } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 546, + 506, + 561 + ], + "score": 1.0, + "content": "weights may depend on the corresponding abstract", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 557, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 557, + 127, + 571 + ], + "score": 1.0, + "content": "state", + "type": "text" + }, + { + "bbox": [ + 127, + 558, + 138, + 568 + ], + "score": 0.87, + "content": "\\mathbf { s } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 557, + 505, + 571 + ], + "score": 1.0, + "content": "and can differ per prediction. This enables the predictron to compute to an adaptive depth", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 569, + 448, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 569, + 448, + 582 + ], + "score": 1.0, + "content": "(Graves, 2016) depending on the internal state and learning dynamics of the network.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 23.5, + "bbox_fs": [ + 104, + 489, + 506, + 582 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 593, + 302, + 606 + ], + "lines": [ + { + "bbox": [ + 105, + 592, + 303, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 303, + 608 + ], + "score": 1.0, + "content": "4 PREDICTRON LEARNING UPDATES", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 106, + 614, + 505, + 659 + ], + "lines": [ + { + "bbox": [ + 106, + 614, + 506, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 614, + 343, + 628 + ], + "score": 1.0, + "content": "We first consider updates that optimise the joint parameters", + "type": "text" + }, + { + "bbox": [ + 344, + 615, + 351, + 625 + ], + "score": 0.81, + "content": "\\pmb { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 614, + 506, + 628 + ], + "score": 1.0, + "content": "of the state representation, model, and", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 626, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 248, + 639 + ], + "score": 1.0, + "content": "value function. We begin with the", + "type": "text" + }, + { + "bbox": [ + 249, + 627, + 255, + 636 + ], + "score": 0.82, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 626, + 385, + 639 + ], + "score": 1.0, + "content": "-step predictron. We update the", + "type": "text" + }, + { + "bbox": [ + 385, + 627, + 392, + 636 + ], + "score": 0.82, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 626, + 457, + 639 + ], + "score": 1.0, + "content": "-step predictron", + "type": "text" + }, + { + "bbox": [ + 457, + 626, + 469, + 637 + ], + "score": 0.9, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 626, + 505, + 639 + ], + "score": 1.0, + "content": "towards", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 636, + 506, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 177, + 650 + ], + "score": 1.0, + "content": "a target outcome", + "type": "text" + }, + { + "bbox": [ + 178, + 639, + 186, + 649 + ], + "score": 0.63, + "content": "\\mathbf { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 636, + 506, + 650 + ], + "score": 1.0, + "content": ", such as the Monte-Carlo return from the real environment, by minimising a", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 649, + 208, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 208, + 660 + ], + "score": 1.0, + "content": "mean-squared error loss,", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 614, + 506, + 660 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 141, + 662, + 468, + 690 + ], + "lines": [ + { + "bbox": [ + 141, + 662, + 468, + 690 + ], + "spans": [ + { + "bbox": [ + 141, + 662, + 468, + 690 + ], + "score": 0.89, + "content": "L ^ { k } = { \\frac { 1 } { 2 } } \\left\\| \\mathbb { E } _ { p } \\left[ \\mathbf { g } \\mid s \\right] - \\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { k } \\mid s \\right] \\right\\| ^ { 2 } . \\qquad { \\frac { \\partial l ^ { k } } { \\partial \\theta } } = \\left( \\mathbf { g } - \\mathbf { g } ^ { k } \\right) { \\frac { \\partial \\mathbf { g } ^ { k } } { \\partial \\theta } } .", + "type": "interline_equation", + "image_path": "351eac7a2de69730f3dab1f5189c90d52d764ae134a2439b606e7ef12358b6b9.jpg" + } + ] + } + ], + "index": 33, + "virtual_lines": [ + { + "bbox": [ + 141, + 662, + 468, + 690 + ], + "spans": [], + "index": 33 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 693, + 505, + 733 + ], + "lines": [ + { + "bbox": [ + 106, + 692, + 506, + 709 + ], + "spans": [ + { + "bbox": [ + 106, + 693, + 134, + 709 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 692, + 210, + 709 + ], + "score": 0.93, + "content": "l ^ { k } = \\textstyle { \\frac { 1 } { 2 } } \\left\\| \\mathbf { g } - \\mathbf { g } ^ { k } \\right\\| ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 693, + 506, + 709 + ], + "score": 1.0, + "content": "is the sample loss. We can use the gradient of the sample loss to update", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 705, + 505, + 720 + ], + "spans": [ + { + "bbox": [ + 105, + 705, + 505, + 720 + ], + "score": 1.0, + "content": "parameters, e.g. by stochastic gradient descent. For stochastic models, two independent samples are", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 716, + 394, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 718, + 156, + 734 + ], + "score": 1.0, + "content": "required for", + "type": "text" + }, + { + "bbox": [ + 156, + 719, + 168, + 732 + ], + "score": 0.87, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 718, + 187, + 734 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 184, + 716, + 206, + 730 + ], + "score": 1.0, + "content": "∂ g k", + "type": "text" + }, + { + "bbox": [ + 204, + 718, + 377, + 734 + ], + "score": 1.0, + "content": "to get unbiased samples for the gradient of", + "type": "text" + }, + { + "bbox": [ + 378, + 721, + 389, + 730 + ], + "score": 0.88, + "content": "L ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 718, + 394, + 734 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 692, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 505, + 106 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 124, + 96 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 124, + 83, + 131, + 92 + ], + "score": 0.78, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 81, + 276, + 96 + ], + "score": 1.0, + "content": "-predictron combines together many", + "type": "text" + }, + { + "bbox": [ + 276, + 83, + 283, + 92 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 81, + 464, + 96 + ], + "score": 1.0, + "content": "-step preturns. To update the joint parameters", + "type": "text" + }, + { + "bbox": [ + 465, + 83, + 471, + 92 + ], + "score": 0.8, + "content": "\\pmb \\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 81, + 505, + 96 + ], + "score": 1.0, + "content": ", we can", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 104, + 89, + 346, + 110 + ], + "spans": [ + { + "bbox": [ + 104, + 89, + 327, + 110 + ], + "score": 1.0, + "content": "uniformly average the losses on the individual preturns", + "type": "text" + }, + { + "bbox": [ + 328, + 93, + 340, + 105 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 89, + 346, + 110 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "interline_equation", + "bbox": [ + 122, + 109, + 477, + 145 + ], + "lines": [ + { + "bbox": [ + 122, + 109, + 477, + 145 + ], + "spans": [ + { + "bbox": [ + 122, + 109, + 477, + 145 + ], + "score": 0.93, + "content": "L ^ { 0 : K } = \\frac { 1 } { 2 K } \\sum _ { k = 0 } ^ { K } \\left\\| \\mathbb { E } _ { p } \\left[ \\mathbf { g } \\mid s \\right] - \\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { k } \\mid s \\right] \\right\\| ^ { 2 } , \\qquad \\frac { \\partial l ^ { 0 : K } } { \\partial \\theta } = \\frac { 1 } { K } \\sum _ { k = 0 } ^ { K } \\left( \\mathbf { g } - \\mathbf { g } ^ { k } \\right) \\frac { \\partial \\mathbf { g } ^ { k } } { \\partial \\theta } .", + "type": "interline_equation", + "image_path": "0c90f66f7c185d870095fba4c191fd03f8dfa64dd7bf7c1c35ee13b6c046dadd.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 122, + 109, + 477, + 121.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 122, + 121.0, + 477, + 133.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 122, + 133.0, + 477, + 145.0 + ], + "spans": [], + "index": 4 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 149, + 505, + 177 + ], + "lines": [ + { + "bbox": [ + 106, + 148, + 505, + 164 + ], + "spans": [ + { + "bbox": [ + 106, + 148, + 316, + 164 + ], + "score": 1.0, + "content": "Alternative, we could weight each loss by the usage", + "type": "text" + }, + { + "bbox": [ + 317, + 149, + 331, + 160 + ], + "score": 0.9, + "content": "\\boldsymbol { w } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 148, + 505, + 164 + ], + "score": 1.0, + "content": "of the corresponding preturn, such that the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 102, + 157, + 255, + 181 + ], + "spans": [ + { + "bbox": [ + 102, + 157, + 151, + 181 + ], + "score": 1.0, + "content": "gradient is", + "type": "text" + }, + { + "bbox": [ + 151, + 162, + 250, + 178 + ], + "score": 0.91, + "content": "\\begin{array} { r } { \\sum _ { k = 0 } ^ { K } \\pmb { w } ^ { k } \\left( \\mathbf { g } - \\mathbf { g } ^ { k } \\right) \\frac { \\partial \\mathbf { g } ^ { k } } { \\partial \\pmb { \\theta } } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 159, + 255, + 181 + ], + "score": 1.0, + "content": "\u0001 ∂ g k∂ θ .", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 108, + 179, + 505, + 211 + ], + "lines": [ + { + "bbox": [ + 106, + 178, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 106, + 178, + 126, + 190 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 126, + 178, + 133, + 188 + ], + "score": 0.78, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 178, + 382, + 190 + ], + "score": 1.0, + "content": "-predictron uses an accumulator with additional parameters", + "type": "text" + }, + { + "bbox": [ + 383, + 180, + 391, + 190 + ], + "score": 0.79, + "content": "\\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 391, + 178, + 505, + 190 + ], + "score": 1.0, + "content": "that determine the relative", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 189, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 189, + 174, + 201 + ], + "score": 1.0, + "content": "weighting of the", + "type": "text" + }, + { + "bbox": [ + 174, + 190, + 181, + 199 + ], + "score": 0.84, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 189, + 505, + 201 + ], + "score": 1.0, + "content": "-step preturns. These weights are also updated so as to minimise a mean-squared", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 199, + 163, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 146, + 212 + ], + "score": 1.0, + "content": "error loss", + "type": "text" + }, + { + "bbox": [ + 146, + 199, + 159, + 210 + ], + "score": 0.87, + "content": "L ^ { \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 199, + 163, + 212 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8 + }, + { + "type": "interline_equation", + "bbox": [ + 144, + 215, + 467, + 243 + ], + "lines": [ + { + "bbox": [ + 144, + 215, + 467, + 243 + ], + "spans": [ + { + "bbox": [ + 144, + 215, + 467, + 243 + ], + "score": 0.88, + "content": "L ^ { \\lambda } = \\frac { 1 } { 2 } \\left\\| \\mathbb { E } _ { p } \\left[ \\mathbf { g } \\mid s \\right] - \\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { \\lambda } \\mid s \\right] \\right\\| ^ { 2 } , \\qquad \\frac { \\partial l ^ { \\lambda } } { \\partial \\eta } = \\left( \\mathbf { g } - \\mathbf { g } ^ { \\lambda } \\right) \\frac { \\partial \\mathbf { g } ^ { \\lambda } } { \\partial \\eta } .", + "type": "interline_equation", + "image_path": "01e9a10653c8121ca7431bc9d38a2316a64da433a9cd12cbede9880710b232ad.jpg" + } + ] + } + ], + "index": 11, + "virtual_lines": [ + { + "bbox": [ + 144, + 215, + 467, + 224.33333333333334 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 144, + 224.33333333333334, + 467, + 233.66666666666669 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 144, + 233.66666666666669, + 467, + 243.00000000000003 + ], + "spans": [], + "index": 12 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 250, + 506, + 284 + ], + "lines": [ + { + "bbox": [ + 105, + 250, + 505, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 238, + 263 + ], + "score": 1.0, + "content": "In summary, the joint parameters", + "type": "text" + }, + { + "bbox": [ + 239, + 251, + 245, + 260 + ], + "score": 0.8, + "content": "\\pmb \\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 250, + 350, + 263 + ], + "score": 1.0, + "content": "of the state representation", + "type": "text" + }, + { + "bbox": [ + 350, + 251, + 357, + 262 + ], + "score": 0.84, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 250, + 401, + 263 + ], + "score": 1.0, + "content": ", the model", + "type": "text" + }, + { + "bbox": [ + 402, + 252, + 412, + 260 + ], + "score": 0.78, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 412, + 250, + 505, + 263 + ], + "score": 1.0, + "content": ", and the value function", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 107, + 260, + 506, + 274 + ], + "spans": [ + { + "bbox": [ + 107, + 264, + 113, + 271 + ], + "score": 0.73, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 113, + 260, + 241, + 274 + ], + "score": 1.0, + "content": "are updated to make each of the", + "type": "text" + }, + { + "bbox": [ + 241, + 262, + 248, + 271 + ], + "score": 0.82, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 260, + 302, + 274 + ], + "score": 1.0, + "content": "-step preturns", + "type": "text" + }, + { + "bbox": [ + 303, + 261, + 315, + 273 + ], + "score": 0.9, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 260, + 417, + 274 + ], + "score": 1.0, + "content": "more similar to the target", + "type": "text" + }, + { + "bbox": [ + 417, + 263, + 424, + 273 + ], + "score": 0.47, + "content": "\\mathbf { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 260, + 506, + 274 + ], + "score": 1.0, + "content": ", and the parameters", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 107, + 271, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 107, + 275, + 114, + 284 + ], + "score": 0.7, + "content": "\\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 271, + 140, + 286 + ], + "score": 1.0, + "content": "of the", + "type": "text" + }, + { + "bbox": [ + 140, + 272, + 147, + 282 + ], + "score": 0.82, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 147, + 271, + 338, + 286 + ], + "score": 1.0, + "content": "-accumulator are updated to make the aggregate", + "type": "text" + }, + { + "bbox": [ + 339, + 272, + 345, + 282 + ], + "score": 0.81, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 345, + 271, + 378, + 286 + ], + "score": 1.0, + "content": "-preturn", + "type": "text" + }, + { + "bbox": [ + 379, + 271, + 391, + 283 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 391, + 271, + 505, + 286 + ], + "score": 1.0, + "content": "more similar to the target g.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14 + }, + { + "type": "title", + "bbox": [ + 108, + 293, + 444, + 306 + ], + "lines": [ + { + "bbox": [ + 105, + 293, + 446, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 377, + 307 + ], + "score": 1.0, + "content": "4.1 CONSISTENCY (SEMI-SUPERVISED) LEARNING WITH THE", + "type": "text" + }, + { + "bbox": [ + 378, + 294, + 384, + 304 + ], + "score": 0.75, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 293, + 446, + 307 + ], + "score": 1.0, + "content": "-PREDICTRON", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 310, + 505, + 394 + ], + "lines": [ + { + "bbox": [ + 106, + 311, + 505, + 324 + ], + "spans": [ + { + "bbox": [ + 106, + 311, + 200, + 324 + ], + "score": 1.0, + "content": "Ideally, the predictron", + "type": "text" + }, + { + "bbox": [ + 200, + 311, + 237, + 323 + ], + "score": 0.93, + "content": "( f , m , v )", + "type": "inline_equation" + }, + { + "bbox": [ + 237, + 311, + 505, + 324 + ], + "score": 1.0, + "content": "learns preturns that are all equal in expectation to the true value", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 320, + 507, + 338 + ], + "spans": [ + { + "bbox": [ + 104, + 320, + 225, + 338 + ], + "score": 1.0, + "content": "function of the environment,", + "type": "text" + }, + { + "bbox": [ + 226, + 322, + 368, + 335 + ], + "score": 0.91, + "content": "\\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { k } \\mid s \\right] = \\mathbb { E } _ { p } \\left[ \\mathbf { g } _ { t } \\mid s \\right] = v _ { p } ( s )", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 320, + 507, + 338 + ], + "score": 1.0, + "content": ", in which case the preturns must", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 104, + 334, + 506, + 350 + ], + "spans": [ + { + "bbox": [ + 104, + 334, + 203, + 350 + ], + "score": 1.0, + "content": "be equal in expectation,", + "type": "text" + }, + { + "bbox": [ + 204, + 335, + 402, + 349 + ], + "score": 0.83, + "content": "\\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { 0 } \\mid s \\right] = \\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { 1 } \\mid s \\right] = \\ldots = \\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { K } \\mid s \\right]", + "type": "inline_equation" + }, + { + "bbox": [ + 403, + 334, + 477, + 350 + ], + "score": 1.0, + "content": ". In addition, each", + "type": "text" + }, + { + "bbox": [ + 478, + 336, + 484, + 346 + ], + "score": 0.79, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 485, + 334, + 506, + 350 + ], + "score": 1.0, + "content": "-step", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 346, + 504, + 363 + ], + "spans": [ + { + "bbox": [ + 104, + 346, + 300, + 363 + ], + "score": 1.0, + "content": "preturn must then be equal in expectation to th", + "type": "text" + }, + { + "bbox": [ + 300, + 346, + 320, + 359 + ], + "score": 0.28, + "content": ": \\lambda - p", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 346, + 348, + 363 + ], + "score": 1.0, + "content": "return,", + "type": "text" + }, + { + "bbox": [ + 348, + 348, + 460, + 362 + ], + "score": 0.9, + "content": "\\mathbb { E } _ { m } \\left[ \\mathbf { \\bar { g } } ^ { k } \\mid s \\right] \\mathbf { \\bar { \\Lambda } } = \\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { \\lambda } \\mid s \\right]", + "type": "inline_equation" + }, + { + "bbox": [ + 460, + 346, + 496, + 363 + ], + "score": 1.0, + "content": ", for any", + "type": "text" + }, + { + "bbox": [ + 497, + 349, + 504, + 359 + ], + "score": 0.75, + "content": "\\lambda", + "type": "inline_equation" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 360, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 505, + 373 + ], + "score": 1.0, + "content": "parameters. All these consistency relations between preturns give rise to additional constraints upon", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 371, + 506, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 506, + 383 + ], + "score": 1.0, + "content": "the predictron. Specifically, we may adjust the parameters of the predictron to lead to consistent", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 382, + 300, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 382, + 300, + 395 + ], + "score": 1.0, + "content": "preturns, even in the absence of labelled targets.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 395, + 505, + 418 + ], + "lines": [ + { + "bbox": [ + 105, + 393, + 505, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 263, + 409 + ], + "score": 1.0, + "content": "Concretely, we can adjust each preturn", + "type": "text" + }, + { + "bbox": [ + 264, + 395, + 276, + 407 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 393, + 325, + 409 + ], + "score": 1.0, + "content": "towards the", + "type": "text" + }, + { + "bbox": [ + 326, + 396, + 333, + 406 + ], + "score": 0.78, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 393, + 366, + 409 + ], + "score": 1.0, + "content": "-preturn", + "type": "text" + }, + { + "bbox": [ + 366, + 395, + 378, + 407 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 393, + 505, + 409 + ], + "score": 1.0, + "content": "; in other words, we can update", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 405, + 439, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 439, + 420 + ], + "score": 1.0, + "content": "each individual value estimate towards the best aggregated estimate by minimizing", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5 + }, + { + "type": "interline_equation", + "bbox": [ + 133, + 422, + 478, + 457 + ], + "lines": [ + { + "bbox": [ + 133, + 422, + 478, + 457 + ], + "spans": [ + { + "bbox": [ + 133, + 422, + 478, + 457 + ], + "score": 0.93, + "content": "L = \\frac { 1 } { 2 } \\sum _ { k = 0 } ^ { K } \\left\\| \\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { \\lambda } \\mid s \\right] - \\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { k } \\mid s \\right] \\right\\| ^ { 2 } , \\qquad \\quad \\quad \\frac { \\partial l } { \\partial \\theta } = \\sum _ { k = 0 } ^ { K } \\left( \\mathbf { g } ^ { \\lambda } - \\mathbf { g } ^ { k } \\right) \\frac { \\partial \\mathbf { g } ^ { k } } { \\partial \\theta } .", + "type": "interline_equation", + "image_path": "01111d8b32de3dca2ecfde14ec4f99c730d6eb5016758fe903611948268c3209.jpg" + } + ] + } + ], + "index": 27, + "virtual_lines": [ + { + "bbox": [ + 133, + 422, + 478, + 433.6666666666667 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 133, + 433.6666666666667, + 478, + 445.33333333333337 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 133, + 445.33333333333337, + 478, + 457.00000000000006 + ], + "spans": [], + "index": 28 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 462, + 505, + 519 + ], + "lines": [ + { + "bbox": [ + 105, + 462, + 506, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 128, + 477 + ], + "score": 1.0, + "content": "Here", + "type": "text" + }, + { + "bbox": [ + 128, + 462, + 141, + 475 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 462, + 284, + 477 + ], + "score": 1.0, + "content": "is considered fixed; the parameters", + "type": "text" + }, + { + "bbox": [ + 284, + 464, + 291, + 473 + ], + "score": 0.8, + "content": "\\pmb \\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 291, + 462, + 396, + 477 + ], + "score": 1.0, + "content": "are only updated to make", + "type": "text" + }, + { + "bbox": [ + 396, + 462, + 408, + 475 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 462, + 473, + 477 + ], + "score": 1.0, + "content": "more similar to", + "type": "text" + }, + { + "bbox": [ + 473, + 462, + 486, + 475 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 462, + 506, + 477 + ], + "score": 1.0, + "content": ", not", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 474, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 359, + 487 + ], + "score": 1.0, + "content": "vice versa. This consistency update does not require any labels", + "type": "text" + }, + { + "bbox": [ + 360, + 477, + 367, + 486 + ], + "score": 0.35, + "content": "\\mathbf { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 368, + 474, + 505, + 487 + ], + "score": 1.0, + "content": "or samples from the environment.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 483, + 506, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 500 + ], + "score": 1.0, + "content": "As a result, it can be applied to (potentially hypothetical) states that have no associated ‘real’ (e.g.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 496, + 505, + 508 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 505, + 508 + ], + "score": 1.0, + "content": "Monte-Carlo) outcome: we update the value estimates to be self-consistent with each other. Note", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 507, + 450, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 507, + 450, + 519 + ], + "score": 1.0, + "content": "the similarity with the semi-supervised setting, where we may have unlabelled inputs.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31 + }, + { + "type": "title", + "bbox": [ + 108, + 531, + 200, + 544 + ], + "lines": [ + { + "bbox": [ + 105, + 531, + 201, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 201, + 546 + ], + "score": 1.0, + "content": "5 EXPERIMENTS", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 552, + 505, + 664 + ], + "lines": [ + { + "bbox": [ + 106, + 553, + 504, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 553, + 474, + 565 + ], + "score": 1.0, + "content": "We conducted experiments on two domains. The first domain consists of randomly generated", + "type": "text" + }, + { + "bbox": [ + 474, + 554, + 504, + 564 + ], + "score": 0.89, + "content": "2 0 \\times 2 0", + "type": "inline_equation" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 565, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 106, + 565, + 505, + 576 + ], + "score": 1.0, + "content": "mazes in which each location either is empty or contains a wall. Two locations in a maze are consid-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 576, + 504, + 587 + ], + "spans": [ + { + "bbox": [ + 106, + 576, + 504, + 587 + ], + "score": 1.0, + "content": "ered connected if they are both empty and we can reach one from the other by moving horizontally", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 586, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 505, + 599 + ], + "score": 1.0, + "content": "or vertically through adjacent empty cells. The goal is to predict, for each of the locations on the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 596, + 506, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 506, + 611 + ], + "score": 1.0, + "content": "diagonal from top-left to bottom-right of the maze, whether the bottom-right corner is connected to", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 608, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 608, + 505, + 621 + ], + "score": 1.0, + "content": "that location, given the entire maze as an input image. Some of these predictions will be straightfor-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 619, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 106, + 619, + 505, + 632 + ], + "score": 1.0, + "content": "ward, for instance for locations on the diagonal that contain a wall themselves and for locations close", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 630, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 106, + 630, + 505, + 643 + ], + "score": 1.0, + "content": "to the bottom right. Many other predictive questions seem to require a simple algorithm, such as", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "score": 1.0, + "content": "some form of a flood fill or search; our hypothesis is that an internal model can learn to emulate such", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 652, + 503, + 665 + ], + "spans": [ + { + "bbox": [ + 106, + 652, + 503, + 665 + ], + "score": 1.0, + "content": "algorithms, where naive approximation may struggle. A few example mazes are shown in Figure 2.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 39.5 + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "score": 1.0, + "content": "Our second domain is a simulation of the game of pool, using four balls and four pockets. The simu-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "score": 1.0, + "content": "lator is implemented in the physics engine Mujoco (Todorov et al., 2012). We generate sequences of", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 687, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 701 + ], + "score": 1.0, + "content": "RGB frames starting from a random arrangement of balls on the table. The goal is to simultaneously", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "learn to predict future events for each of the four balls, given 5 RGB frames as input. These events", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "include: collision with any other ball, collision with any boundary of the table, entering a quadrant", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 110, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 110, + 721, + 124, + 732 + ], + "score": 0.81, + "content": "\\times 4", + "type": "inline_equation" + }, + { + "bbox": [ + 124, + 720, + 320, + 733 + ], + "score": 1.0, + "content": ", for each quadrant), being located in a quadrant", + "type": "text" + }, + { + "bbox": [ + 321, + 721, + 335, + 731 + ], + "score": 0.83, + "content": "\\times 4", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 720, + 505, + 733 + ], + "score": 1.0, + "content": ", for each quadrant), and entering a pocket", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 47.5 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 26, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 12, + "width": 8 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 505, + 106 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 124, + 96 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 124, + 83, + 131, + 92 + ], + "score": 0.78, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 81, + 276, + 96 + ], + "score": 1.0, + "content": "-predictron combines together many", + "type": "text" + }, + { + "bbox": [ + 276, + 83, + 283, + 92 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 81, + 464, + 96 + ], + "score": 1.0, + "content": "-step preturns. To update the joint parameters", + "type": "text" + }, + { + "bbox": [ + 465, + 83, + 471, + 92 + ], + "score": 0.8, + "content": "\\pmb \\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 81, + 505, + 96 + ], + "score": 1.0, + "content": ", we can", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 104, + 89, + 346, + 110 + ], + "spans": [ + { + "bbox": [ + 104, + 89, + 327, + 110 + ], + "score": 1.0, + "content": "uniformly average the losses on the individual preturns", + "type": "text" + }, + { + "bbox": [ + 328, + 93, + 340, + 105 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 89, + 346, + 110 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 104, + 81, + 505, + 110 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 122, + 109, + 477, + 145 + ], + "lines": [ + { + "bbox": [ + 122, + 109, + 477, + 145 + ], + "spans": [ + { + "bbox": [ + 122, + 109, + 477, + 145 + ], + "score": 0.93, + "content": "L ^ { 0 : K } = \\frac { 1 } { 2 K } \\sum _ { k = 0 } ^ { K } \\left\\| \\mathbb { E } _ { p } \\left[ \\mathbf { g } \\mid s \\right] - \\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { k } \\mid s \\right] \\right\\| ^ { 2 } , \\qquad \\frac { \\partial l ^ { 0 : K } } { \\partial \\theta } = \\frac { 1 } { K } \\sum _ { k = 0 } ^ { K } \\left( \\mathbf { g } - \\mathbf { g } ^ { k } \\right) \\frac { \\partial \\mathbf { g } ^ { k } } { \\partial \\theta } .", + "type": "interline_equation", + "image_path": "0c90f66f7c185d870095fba4c191fd03f8dfa64dd7bf7c1c35ee13b6c046dadd.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 122, + 109, + 477, + 121.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 122, + 121.0, + 477, + 133.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 122, + 133.0, + 477, + 145.0 + ], + "spans": [], + "index": 4 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 149, + 505, + 177 + ], + "lines": [ + { + "bbox": [ + 106, + 148, + 505, + 164 + ], + "spans": [ + { + "bbox": [ + 106, + 148, + 316, + 164 + ], + "score": 1.0, + "content": "Alternative, we could weight each loss by the usage", + "type": "text" + }, + { + "bbox": [ + 317, + 149, + 331, + 160 + ], + "score": 0.9, + "content": "\\boldsymbol { w } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 148, + 505, + 164 + ], + "score": 1.0, + "content": "of the corresponding preturn, such that the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 102, + 157, + 255, + 181 + ], + "spans": [ + { + "bbox": [ + 102, + 157, + 151, + 181 + ], + "score": 1.0, + "content": "gradient is", + "type": "text" + }, + { + "bbox": [ + 151, + 162, + 250, + 178 + ], + "score": 0.91, + "content": "\\begin{array} { r } { \\sum _ { k = 0 } ^ { K } \\pmb { w } ^ { k } \\left( \\mathbf { g } - \\mathbf { g } ^ { k } \\right) \\frac { \\partial \\mathbf { g } ^ { k } } { \\partial \\pmb { \\theta } } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 159, + 255, + 181 + ], + "score": 1.0, + "content": "\u0001 ∂ g k∂ θ .", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5, + "bbox_fs": [ + 102, + 148, + 505, + 181 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 179, + 505, + 211 + ], + "lines": [ + { + "bbox": [ + 106, + 178, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 106, + 178, + 126, + 190 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 126, + 178, + 133, + 188 + ], + "score": 0.78, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 178, + 382, + 190 + ], + "score": 1.0, + "content": "-predictron uses an accumulator with additional parameters", + "type": "text" + }, + { + "bbox": [ + 383, + 180, + 391, + 190 + ], + "score": 0.79, + "content": "\\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 391, + 178, + 505, + 190 + ], + "score": 1.0, + "content": "that determine the relative", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 189, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 189, + 174, + 201 + ], + "score": 1.0, + "content": "weighting of the", + "type": "text" + }, + { + "bbox": [ + 174, + 190, + 181, + 199 + ], + "score": 0.84, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 189, + 505, + 201 + ], + "score": 1.0, + "content": "-step preturns. These weights are also updated so as to minimise a mean-squared", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 199, + 163, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 146, + 212 + ], + "score": 1.0, + "content": "error loss", + "type": "text" + }, + { + "bbox": [ + 146, + 199, + 159, + 210 + ], + "score": 0.87, + "content": "L ^ { \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 199, + 163, + 212 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 178, + 505, + 212 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 144, + 215, + 467, + 243 + ], + "lines": [ + { + "bbox": [ + 144, + 215, + 467, + 243 + ], + "spans": [ + { + "bbox": [ + 144, + 215, + 467, + 243 + ], + "score": 0.88, + "content": "L ^ { \\lambda } = \\frac { 1 } { 2 } \\left\\| \\mathbb { E } _ { p } \\left[ \\mathbf { g } \\mid s \\right] - \\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { \\lambda } \\mid s \\right] \\right\\| ^ { 2 } , \\qquad \\frac { \\partial l ^ { \\lambda } } { \\partial \\eta } = \\left( \\mathbf { g } - \\mathbf { g } ^ { \\lambda } \\right) \\frac { \\partial \\mathbf { g } ^ { \\lambda } } { \\partial \\eta } .", + "type": "interline_equation", + "image_path": "01e9a10653c8121ca7431bc9d38a2316a64da433a9cd12cbede9880710b232ad.jpg" + } + ] + } + ], + "index": 11, + "virtual_lines": [ + { + "bbox": [ + 144, + 215, + 467, + 224.33333333333334 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 144, + 224.33333333333334, + 467, + 233.66666666666669 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 144, + 233.66666666666669, + 467, + 243.00000000000003 + ], + "spans": [], + "index": 12 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 250, + 506, + 284 + ], + "lines": [ + { + "bbox": [ + 105, + 250, + 505, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 238, + 263 + ], + "score": 1.0, + "content": "In summary, the joint parameters", + "type": "text" + }, + { + "bbox": [ + 239, + 251, + 245, + 260 + ], + "score": 0.8, + "content": "\\pmb \\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 250, + 350, + 263 + ], + "score": 1.0, + "content": "of the state representation", + "type": "text" + }, + { + "bbox": [ + 350, + 251, + 357, + 262 + ], + "score": 0.84, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 250, + 401, + 263 + ], + "score": 1.0, + "content": ", the model", + "type": "text" + }, + { + "bbox": [ + 402, + 252, + 412, + 260 + ], + "score": 0.78, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 412, + 250, + 505, + 263 + ], + "score": 1.0, + "content": ", and the value function", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 107, + 260, + 506, + 274 + ], + "spans": [ + { + "bbox": [ + 107, + 264, + 113, + 271 + ], + "score": 0.73, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 113, + 260, + 241, + 274 + ], + "score": 1.0, + "content": "are updated to make each of the", + "type": "text" + }, + { + "bbox": [ + 241, + 262, + 248, + 271 + ], + "score": 0.82, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 260, + 302, + 274 + ], + "score": 1.0, + "content": "-step preturns", + "type": "text" + }, + { + "bbox": [ + 303, + 261, + 315, + 273 + ], + "score": 0.9, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 260, + 417, + 274 + ], + "score": 1.0, + "content": "more similar to the target", + "type": "text" + }, + { + "bbox": [ + 417, + 263, + 424, + 273 + ], + "score": 0.47, + "content": "\\mathbf { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 260, + 506, + 274 + ], + "score": 1.0, + "content": ", and the parameters", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 107, + 271, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 107, + 275, + 114, + 284 + ], + "score": 0.7, + "content": "\\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 271, + 140, + 286 + ], + "score": 1.0, + "content": "of the", + "type": "text" + }, + { + "bbox": [ + 140, + 272, + 147, + 282 + ], + "score": 0.82, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 147, + 271, + 338, + 286 + ], + "score": 1.0, + "content": "-accumulator are updated to make the aggregate", + "type": "text" + }, + { + "bbox": [ + 339, + 272, + 345, + 282 + ], + "score": 0.81, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 345, + 271, + 378, + 286 + ], + "score": 1.0, + "content": "-preturn", + "type": "text" + }, + { + "bbox": [ + 379, + 271, + 391, + 283 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 391, + 271, + 505, + 286 + ], + "score": 1.0, + "content": "more similar to the target g.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14, + "bbox_fs": [ + 105, + 250, + 506, + 286 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 293, + 444, + 306 + ], + "lines": [ + { + "bbox": [ + 105, + 293, + 446, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 377, + 307 + ], + "score": 1.0, + "content": "4.1 CONSISTENCY (SEMI-SUPERVISED) LEARNING WITH THE", + "type": "text" + }, + { + "bbox": [ + 378, + 294, + 384, + 304 + ], + "score": 0.75, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 293, + 446, + 307 + ], + "score": 1.0, + "content": "-PREDICTRON", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 310, + 505, + 394 + ], + "lines": [ + { + "bbox": [ + 106, + 311, + 505, + 324 + ], + "spans": [ + { + "bbox": [ + 106, + 311, + 200, + 324 + ], + "score": 1.0, + "content": "Ideally, the predictron", + "type": "text" + }, + { + "bbox": [ + 200, + 311, + 237, + 323 + ], + "score": 0.93, + "content": "( f , m , v )", + "type": "inline_equation" + }, + { + "bbox": [ + 237, + 311, + 505, + 324 + ], + "score": 1.0, + "content": "learns preturns that are all equal in expectation to the true value", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 320, + 507, + 338 + ], + "spans": [ + { + "bbox": [ + 104, + 320, + 225, + 338 + ], + "score": 1.0, + "content": "function of the environment,", + "type": "text" + }, + { + "bbox": [ + 226, + 322, + 368, + 335 + ], + "score": 0.91, + "content": "\\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { k } \\mid s \\right] = \\mathbb { E } _ { p } \\left[ \\mathbf { g } _ { t } \\mid s \\right] = v _ { p } ( s )", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 320, + 507, + 338 + ], + "score": 1.0, + "content": ", in which case the preturns must", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 104, + 334, + 506, + 350 + ], + "spans": [ + { + "bbox": [ + 104, + 334, + 203, + 350 + ], + "score": 1.0, + "content": "be equal in expectation,", + "type": "text" + }, + { + "bbox": [ + 204, + 335, + 402, + 349 + ], + "score": 0.83, + "content": "\\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { 0 } \\mid s \\right] = \\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { 1 } \\mid s \\right] = \\ldots = \\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { K } \\mid s \\right]", + "type": "inline_equation" + }, + { + "bbox": [ + 403, + 334, + 477, + 350 + ], + "score": 1.0, + "content": ". In addition, each", + "type": "text" + }, + { + "bbox": [ + 478, + 336, + 484, + 346 + ], + "score": 0.79, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 485, + 334, + 506, + 350 + ], + "score": 1.0, + "content": "-step", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 346, + 504, + 363 + ], + "spans": [ + { + "bbox": [ + 104, + 346, + 300, + 363 + ], + "score": 1.0, + "content": "preturn must then be equal in expectation to th", + "type": "text" + }, + { + "bbox": [ + 300, + 346, + 320, + 359 + ], + "score": 0.28, + "content": ": \\lambda - p", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 346, + 348, + 363 + ], + "score": 1.0, + "content": "return,", + "type": "text" + }, + { + "bbox": [ + 348, + 348, + 460, + 362 + ], + "score": 0.9, + "content": "\\mathbb { E } _ { m } \\left[ \\mathbf { \\bar { g } } ^ { k } \\mid s \\right] \\mathbf { \\bar { \\Lambda } } = \\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { \\lambda } \\mid s \\right]", + "type": "inline_equation" + }, + { + "bbox": [ + 460, + 346, + 496, + 363 + ], + "score": 1.0, + "content": ", for any", + "type": "text" + }, + { + "bbox": [ + 497, + 349, + 504, + 359 + ], + "score": 0.75, + "content": "\\lambda", + "type": "inline_equation" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 360, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 505, + 373 + ], + "score": 1.0, + "content": "parameters. All these consistency relations between preturns give rise to additional constraints upon", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 371, + 506, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 506, + 383 + ], + "score": 1.0, + "content": "the predictron. Specifically, we may adjust the parameters of the predictron to lead to consistent", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 382, + 300, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 382, + 300, + 395 + ], + "score": 1.0, + "content": "preturns, even in the absence of labelled targets.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20, + "bbox_fs": [ + 104, + 311, + 507, + 395 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 395, + 505, + 418 + ], + "lines": [ + { + "bbox": [ + 105, + 393, + 505, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 263, + 409 + ], + "score": 1.0, + "content": "Concretely, we can adjust each preturn", + "type": "text" + }, + { + "bbox": [ + 264, + 395, + 276, + 407 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 393, + 325, + 409 + ], + "score": 1.0, + "content": "towards the", + "type": "text" + }, + { + "bbox": [ + 326, + 396, + 333, + 406 + ], + "score": 0.78, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 393, + 366, + 409 + ], + "score": 1.0, + "content": "-preturn", + "type": "text" + }, + { + "bbox": [ + 366, + 395, + 378, + 407 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 393, + 505, + 409 + ], + "score": 1.0, + "content": "; in other words, we can update", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 405, + 439, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 439, + 420 + ], + "score": 1.0, + "content": "each individual value estimate towards the best aggregated estimate by minimizing", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5, + "bbox_fs": [ + 105, + 393, + 505, + 420 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 133, + 422, + 478, + 457 + ], + "lines": [ + { + "bbox": [ + 133, + 422, + 478, + 457 + ], + "spans": [ + { + "bbox": [ + 133, + 422, + 478, + 457 + ], + "score": 0.93, + "content": "L = \\frac { 1 } { 2 } \\sum _ { k = 0 } ^ { K } \\left\\| \\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { \\lambda } \\mid s \\right] - \\mathbb { E } _ { m } \\left[ \\mathbf { g } ^ { k } \\mid s \\right] \\right\\| ^ { 2 } , \\qquad \\quad \\quad \\frac { \\partial l } { \\partial \\theta } = \\sum _ { k = 0 } ^ { K } \\left( \\mathbf { g } ^ { \\lambda } - \\mathbf { g } ^ { k } \\right) \\frac { \\partial \\mathbf { g } ^ { k } } { \\partial \\theta } .", + "type": "interline_equation", + "image_path": "01111d8b32de3dca2ecfde14ec4f99c730d6eb5016758fe903611948268c3209.jpg" + } + ] + } + ], + "index": 27, + "virtual_lines": [ + { + "bbox": [ + 133, + 422, + 478, + 433.6666666666667 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 133, + 433.6666666666667, + 478, + 445.33333333333337 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 133, + 445.33333333333337, + 478, + 457.00000000000006 + ], + "spans": [], + "index": 28 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 462, + 505, + 519 + ], + "lines": [ + { + "bbox": [ + 105, + 462, + 506, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 128, + 477 + ], + "score": 1.0, + "content": "Here", + "type": "text" + }, + { + "bbox": [ + 128, + 462, + 141, + 475 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 462, + 284, + 477 + ], + "score": 1.0, + "content": "is considered fixed; the parameters", + "type": "text" + }, + { + "bbox": [ + 284, + 464, + 291, + 473 + ], + "score": 0.8, + "content": "\\pmb \\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 291, + 462, + 396, + 477 + ], + "score": 1.0, + "content": "are only updated to make", + "type": "text" + }, + { + "bbox": [ + 396, + 462, + 408, + 475 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 462, + 473, + 477 + ], + "score": 1.0, + "content": "more similar to", + "type": "text" + }, + { + "bbox": [ + 473, + 462, + 486, + 475 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 462, + 506, + 477 + ], + "score": 1.0, + "content": ", not", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 474, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 359, + 487 + ], + "score": 1.0, + "content": "vice versa. This consistency update does not require any labels", + "type": "text" + }, + { + "bbox": [ + 360, + 477, + 367, + 486 + ], + "score": 0.35, + "content": "\\mathbf { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 368, + 474, + 505, + 487 + ], + "score": 1.0, + "content": "or samples from the environment.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 483, + 506, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 500 + ], + "score": 1.0, + "content": "As a result, it can be applied to (potentially hypothetical) states that have no associated ‘real’ (e.g.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 496, + 505, + 508 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 505, + 508 + ], + "score": 1.0, + "content": "Monte-Carlo) outcome: we update the value estimates to be self-consistent with each other. Note", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 507, + 450, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 507, + 450, + 519 + ], + "score": 1.0, + "content": "the similarity with the semi-supervised setting, where we may have unlabelled inputs.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31, + "bbox_fs": [ + 105, + 462, + 506, + 519 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 531, + 200, + 544 + ], + "lines": [ + { + "bbox": [ + 105, + 531, + 201, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 201, + 546 + ], + "score": 1.0, + "content": "5 EXPERIMENTS", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 552, + 505, + 664 + ], + "lines": [ + { + "bbox": [ + 106, + 553, + 504, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 553, + 474, + 565 + ], + "score": 1.0, + "content": "We conducted experiments on two domains. The first domain consists of randomly generated", + "type": "text" + }, + { + "bbox": [ + 474, + 554, + 504, + 564 + ], + "score": 0.89, + "content": "2 0 \\times 2 0", + "type": "inline_equation" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 565, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 106, + 565, + 505, + 576 + ], + "score": 1.0, + "content": "mazes in which each location either is empty or contains a wall. Two locations in a maze are consid-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 576, + 504, + 587 + ], + "spans": [ + { + "bbox": [ + 106, + 576, + 504, + 587 + ], + "score": 1.0, + "content": "ered connected if they are both empty and we can reach one from the other by moving horizontally", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 586, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 505, + 599 + ], + "score": 1.0, + "content": "or vertically through adjacent empty cells. The goal is to predict, for each of the locations on the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 596, + 506, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 506, + 611 + ], + "score": 1.0, + "content": "diagonal from top-left to bottom-right of the maze, whether the bottom-right corner is connected to", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 608, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 608, + 505, + 621 + ], + "score": 1.0, + "content": "that location, given the entire maze as an input image. Some of these predictions will be straightfor-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 619, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 106, + 619, + 505, + 632 + ], + "score": 1.0, + "content": "ward, for instance for locations on the diagonal that contain a wall themselves and for locations close", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 630, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 106, + 630, + 505, + 643 + ], + "score": 1.0, + "content": "to the bottom right. Many other predictive questions seem to require a simple algorithm, such as", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "score": 1.0, + "content": "some form of a flood fill or search; our hypothesis is that an internal model can learn to emulate such", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 652, + 503, + 665 + ], + "spans": [ + { + "bbox": [ + 106, + 652, + 503, + 665 + ], + "score": 1.0, + "content": "algorithms, where naive approximation may struggle. A few example mazes are shown in Figure 2.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 39.5, + "bbox_fs": [ + 105, + 553, + 506, + 665 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "score": 1.0, + "content": "Our second domain is a simulation of the game of pool, using four balls and four pockets. The simu-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "score": 1.0, + "content": "lator is implemented in the physics engine Mujoco (Todorov et al., 2012). We generate sequences of", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 687, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 701 + ], + "score": 1.0, + "content": "RGB frames starting from a random arrangement of balls on the table. The goal is to simultaneously", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "learn to predict future events for each of the four balls, given 5 RGB frames as input. These events", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "include: collision with any other ball, collision with any boundary of the table, entering a quadrant", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 110, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 110, + 721, + 124, + 732 + ], + "score": 0.81, + "content": "\\times 4", + "type": "inline_equation" + }, + { + "bbox": [ + 124, + 720, + 320, + 733 + ], + "score": 1.0, + "content": ", for each quadrant), being located in a quadrant", + "type": "text" + }, + { + "bbox": [ + 321, + 721, + 335, + 731 + ], + "score": 0.83, + "content": "\\times 4", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 720, + 505, + 733 + ], + "score": 1.0, + "content": ", for each quadrant), and entering a pocket", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 109, + 416, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 109, + 417, + 124, + 428 + ], + "score": 0.82, + "content": "( \\times 4", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 124, + 416, + 252, + 429 + ], + "score": 1.0, + "content": ", for each pocket). Each of these", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 252, + 417, + 278, + 427 + ], + "score": 0.88, + "content": "1 4 \\times 4", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 279, + 416, + 505, + 429 + ], + "score": 1.0, + "content": "events provides a binary pseudo-reward that we combine", + "type": "text", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 427, + 504, + 439 + ], + "spans": [ + { + "bbox": [ + 106, + 427, + 239, + 439 + ], + "score": 1.0, + "content": "with 5 different discount factors", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 240, + 428, + 321, + 439 + ], + "score": 0.89, + "content": "\\{ 0 , 0 . 5 , 0 . 9 , 0 . 9 8 , 1 \\}", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 322, + 427, + 504, + 439 + ], + "score": 1.0, + "content": "and predict their cumulative discounted sum", + "type": "text", + "cross_page": true + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 438, + 506, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 438, + 506, + 452 + ], + "score": 1.0, + "content": "over various time spans. This yields a total of 280 general value functions. An example trajectory is", + "type": "text", + "cross_page": true + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 449, + 506, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 449, + 506, + 462 + ], + "score": 1.0, + "content": "shown in Figure 2. In both domains, inputs are presented as minibatches of i.i.d. samples with their", + "type": "text", + "cross_page": true + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 460, + 403, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 403, + 473 + ], + "score": 1.0, + "content": "regression targets. Additional domain details are provided in Appendix E.", + "type": "text", + "cross_page": true + } + ], + "index": 19 + } + ], + "index": 47.5, + "bbox_fs": [ + 105, + 666, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 146, + 81, + 464, + 135 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 146, + 81, + 464, + 135 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 146, + 81, + 464, + 135 + ], + "spans": [ + { + "bbox": [ + 146, + 81, + 464, + 135 + ], + "score": 0.95, + "type": "image", + "image_path": "8a31c76eabf685b5e20aa0765cb76bf5f66494f925957476c5705091f578ef29.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 146, + 81, + 464, + 99.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 146, + 99.0, + 464, + 117.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 146, + 117.0, + 464, + 135.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 140, + 505, + 184 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 139, + 505, + 153 + ], + "spans": [ + { + "bbox": [ + 105, + 139, + 505, + 153 + ], + "score": 1.0, + "content": "Figure 2: Left: Two sample mazes from the random-maze domain. Light blue cells are empty,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 151, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 505, + 163 + ], + "score": 1.0, + "content": "darker blue cells contain a wall. One maze is connected from top-left to bottom-right (indicated in", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 161, + 505, + 175 + ], + "spans": [ + { + "bbox": [ + 105, + 161, + 505, + 175 + ], + "score": 1.0, + "content": "black), the other is not. Right: An example trajectory in the pool domain (before downsampling).", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 173, + 448, + 185 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 448, + 185 + ], + "score": 1.0, + "content": "It was selected by maximising the prediction of pocketing balls, using the predictron.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "image", + "bbox": [ + 113, + 187, + 487, + 349 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 113, + 187, + 487, + 349 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 113, + 187, + 487, + 349 + ], + "spans": [ + { + "bbox": [ + 113, + 187, + 487, + 349 + ], + "score": 0.973, + "type": "image", + "image_path": "e602264f049e19e6be76364d251d62f7e9f44ac88523eb8c4214db23eff3de07.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 113, + 187, + 487, + 241.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 113, + 241.0, + 487, + 295.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 113, + 295.0, + 487, + 349.0 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 354, + 505, + 409 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 353, + 505, + 367 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 505, + 367 + ], + "score": 1.0, + "content": "Figure 3: Exploring predictron variants. Aggregated prediction errors over all predictions (20", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 364, + 505, + 377 + ], + "spans": [ + { + "bbox": [ + 106, + 364, + 505, + 377 + ], + "score": 1.0, + "content": "for mazes, 280 for pool) for the eight predictron variants corresponding to the cube on the left (as", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 375, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 375, + 505, + 388 + ], + "score": 1.0, + "content": "described in the main text), for both random mazes (top) and pool (bottom). Each line is the median", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 385, + 505, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 403, + 399 + ], + "score": 1.0, + "content": "of RMSE over five seeds; shaded regions encompass all seeds. The full", + "type": "text" + }, + { + "bbox": [ + 403, + 387, + 435, + 399 + ], + "score": 0.92, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 436, + 385, + 505, + 399 + ], + "score": 1.0, + "content": "-prediction (red)", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 397, + 221, + 410 + ], + "spans": [ + { + "bbox": [ + 106, + 397, + 221, + 410 + ], + "score": 1.0, + "content": "consistently performed best.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12 + } + ], + "index": 10.0 + }, + { + "type": "text", + "bbox": [ + 107, + 416, + 505, + 472 + ], + "lines": [ + { + "bbox": [ + 109, + 416, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 109, + 417, + 124, + 428 + ], + "score": 0.82, + "content": "( \\times 4", + "type": "inline_equation" + }, + { + "bbox": [ + 124, + 416, + 252, + 429 + ], + "score": 1.0, + "content": ", for each pocket). Each of these", + "type": "text" + }, + { + "bbox": [ + 252, + 417, + 278, + 427 + ], + "score": 0.88, + "content": "1 4 \\times 4", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 416, + 505, + 429 + ], + "score": 1.0, + "content": "events provides a binary pseudo-reward that we combine", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 427, + 504, + 439 + ], + "spans": [ + { + "bbox": [ + 106, + 427, + 239, + 439 + ], + "score": 1.0, + "content": "with 5 different discount factors", + "type": "text" + }, + { + "bbox": [ + 240, + 428, + 321, + 439 + ], + "score": 0.89, + "content": "\\{ 0 , 0 . 5 , 0 . 9 , 0 . 9 8 , 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 427, + 504, + 439 + ], + "score": 1.0, + "content": "and predict their cumulative discounted sum", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 438, + 506, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 438, + 506, + 452 + ], + "score": 1.0, + "content": "over various time spans. This yields a total of 280 general value functions. An example trajectory is", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 449, + 506, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 449, + 506, + 462 + ], + "score": 1.0, + "content": "shown in Figure 2. In both domains, inputs are presented as minibatches of i.i.d. samples with their", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 460, + 403, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 403, + 473 + ], + "score": 1.0, + "content": "regression targets. Additional domain details are provided in Appendix E.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 17 + }, + { + "type": "title", + "bbox": [ + 107, + 483, + 331, + 494 + ], + "lines": [ + { + "bbox": [ + 106, + 483, + 332, + 496 + ], + "spans": [ + { + "bbox": [ + 106, + 483, + 332, + 496 + ], + "score": 1.0, + "content": "5.1 EXPLORING THE PREDICTRON ARCHITECTURE", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 108, + 501, + 505, + 534 + ], + "lines": [ + { + "bbox": [ + 105, + 500, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 505, + 514 + ], + "score": 1.0, + "content": "Our first set of experiments examines three binary dimensions that differentiate the predictron from", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 512, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 505, + 524 + ], + "score": 1.0, + "content": "standard deep networks. We compare eight predictron variants corresponding to the corners of the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 523, + 220, + 535 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 220, + 535 + ], + "score": 1.0, + "content": "cube on the left in Figure 3.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 537, + 505, + 581 + ], + "lines": [ + { + "bbox": [ + 105, + 536, + 506, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 506, + 549 + ], + "score": 1.0, + "content": "The first dimension corresponds to whether or not the predictron architecture utilises the structure of", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 547, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 279, + 560 + ], + "score": 1.0, + "content": "an MRP model. In the MRP case, labelled", + "type": "text" + }, + { + "bbox": [ + 280, + 549, + 295, + 559 + ], + "score": 0.87, + "content": "r , \\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 547, + 505, + 560 + ], + "score": 1.0, + "content": ", internal rewards and discounts are both learned. In", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 559, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 106, + 559, + 140, + 571 + ], + "score": 1.0, + "content": "the non-", + "type": "text" + }, + { + "bbox": [ + 140, + 562, + 145, + 569 + ], + "score": 0.64, + "content": "r", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 559, + 148, + 571 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 148, + 561, + 156, + 570 + ], + "score": 0.72, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 156, + 559, + 505, + 571 + ], + "score": 1.0, + "content": "case, which corresponds to a vanilla hidden-to-hidden neural network module, internal", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 569, + 425, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 341, + 581 + ], + "score": 1.0, + "content": "rewards and discounts are ignored by fixing their values to", + "type": "text" + }, + { + "bbox": [ + 342, + 569, + 372, + 580 + ], + "score": 0.92, + "content": "\\mathbf { r } ^ { k } = \\mathbf { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 569, + 389, + 581 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 389, + 569, + 420, + 581 + ], + "score": 0.92, + "content": "\\gamma ^ { k } = \\mathbf { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 421, + 569, + 425, + 581 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 107, + 583, + 505, + 628 + ], + "lines": [ + { + "bbox": [ + 105, + 583, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 249, + 595 + ], + "score": 1.0, + "content": "The second dimension is whether a", + "type": "text" + }, + { + "bbox": [ + 249, + 583, + 260, + 594 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 583, + 343, + 595 + ], + "score": 1.0, + "content": "-step accumulator or", + "type": "text" + }, + { + "bbox": [ + 343, + 583, + 350, + 594 + ], + "score": 0.8, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 583, + 505, + 595 + ], + "score": 1.0, + "content": "-accumulator is used to aggregate over", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 595, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 178, + 606 + ], + "score": 1.0, + "content": "preturns. When a", + "type": "text" + }, + { + "bbox": [ + 179, + 595, + 186, + 605 + ], + "score": 0.77, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 595, + 279, + 606 + ], + "score": 1.0, + "content": "-accumulator is used, a", + "type": "text" + }, + { + "bbox": [ + 279, + 595, + 286, + 605 + ], + "score": 0.77, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 287, + 595, + 505, + 606 + ], + "score": 1.0, + "content": "-preturn is computed as described in Section 3. Other-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 605, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 361, + 617 + ], + "score": 1.0, + "content": "wise, intermediate preturns are ignored by fixing their values to", + "type": "text" + }, + { + "bbox": [ + 361, + 605, + 392, + 615 + ], + "score": 0.91, + "content": "\\lambda ^ { k } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 605, + 407, + 617 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 407, + 605, + 436, + 615 + ], + "score": 0.91, + "content": "k < K", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 605, + 505, + 617 + ], + "score": 1.0, + "content": ". In this case, the", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 103, + 615, + 405, + 630 + ], + "spans": [ + { + "bbox": [ + 103, + 615, + 386, + 630 + ], + "score": 1.0, + "content": "overall output of the predictron is simply the maximum-depth preturn", + "type": "text" + }, + { + "bbox": [ + 386, + 616, + 401, + 628 + ], + "score": 0.88, + "content": "\\mathbf { g } ^ { K }", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 615, + 405, + 630 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 107, + 630, + 505, + 696 + ], + "lines": [ + { + "bbox": [ + 105, + 629, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 505, + 642 + ], + "score": 1.0, + "content": "The third dimension, labelled usage weighting, defines the loss that is used to update the parameters", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 107, + 640, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 107, + 641, + 114, + 651 + ], + "score": 0.57, + "content": "\\pmb \\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 640, + 505, + 653 + ], + "score": 1.0, + "content": ". On this dimension, we consider two options: the preturn losses can either be weighted uniformly", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 651, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 296, + 664 + ], + "score": 1.0, + "content": "(see Equation 6), or the update for each preturn", + "type": "text" + }, + { + "bbox": [ + 296, + 651, + 308, + 663 + ], + "score": 0.91, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 651, + 471, + 664 + ], + "score": 1.0, + "content": "can be weighted according to the weight", + "type": "text" + }, + { + "bbox": [ + 472, + 651, + 486, + 662 + ], + "score": 0.89, + "content": "\\boldsymbol { w } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 651, + 506, + 664 + ], + "score": 1.0, + "content": "that", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 661, + 506, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 661, + 263, + 676 + ], + "score": 1.0, + "content": "determines how much it is used in the", + "type": "text" + }, + { + "bbox": [ + 263, + 663, + 271, + 673 + ], + "score": 0.8, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 661, + 506, + 676 + ], + "score": 1.0, + "content": "-predictron’s overall output. We call the latter loss ‘usage", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 672, + 507, + 687 + ], + "spans": [ + { + "bbox": [ + 105, + 672, + 300, + 687 + ], + "score": 1.0, + "content": "weighted‘. Note that for architectures without a", + "type": "text" + }, + { + "bbox": [ + 301, + 675, + 308, + 684 + ], + "score": 0.81, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 672, + 364, + 687 + ], + "score": 1.0, + "content": "-accumulator,", + "type": "text" + }, + { + "bbox": [ + 364, + 673, + 398, + 684 + ], + "score": 0.92, + "content": "\\bar { \\boldsymbol { w } } ^ { k } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 398, + 672, + 413, + 687 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 414, + 674, + 443, + 684 + ], + "score": 0.9, + "content": "k < K", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 672, + 464, + 687 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 465, + 673, + 501, + 684 + ], + "score": 0.91, + "content": "\\mathbf { \\Delta } w ^ { K } = \\mathbf { \\bar { \\mu } }", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 672, + 507, + 687 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 682, + 464, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 444, + 699 + ], + "score": 1.0, + "content": "thus usage weighting then implies backpropagating only the loss on the final preturn", + "type": "text" + }, + { + "bbox": [ + 445, + 684, + 459, + 696 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { K }", + "type": "inline_equation" + }, + { + "bbox": [ + 460, + 682, + 464, + 699 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 34.5 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "All variants utilise a convolutional core with 2 intermediate hidden layers (see Appendix A); param-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 340, + 721 + ], + "score": 1.0, + "content": "eters were updated by supervised learning (see Appendix", + "type": "text" + }, + { + "bbox": [ + 340, + 710, + 348, + 720 + ], + "score": 0.3, + "content": "\\mathbf { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 709, + 505, + 721 + ], + "score": 1.0, + "content": "for more details). Root mean squared", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "prediction errors for each architecture, aggregated over all predictions, are shown in Figure 3. The", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39 + } + ], + "page_idx": 4, + "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, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 146, + 81, + 464, + 135 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 146, + 81, + 464, + 135 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 146, + 81, + 464, + 135 + ], + "spans": [ + { + "bbox": [ + 146, + 81, + 464, + 135 + ], + "score": 0.95, + "type": "image", + "image_path": "8a31c76eabf685b5e20aa0765cb76bf5f66494f925957476c5705091f578ef29.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 146, + 81, + 464, + 99.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 146, + 99.0, + 464, + 117.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 146, + 117.0, + 464, + 135.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 140, + 505, + 184 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 139, + 505, + 153 + ], + "spans": [ + { + "bbox": [ + 105, + 139, + 505, + 153 + ], + "score": 1.0, + "content": "Figure 2: Left: Two sample mazes from the random-maze domain. Light blue cells are empty,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 151, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 505, + 163 + ], + "score": 1.0, + "content": "darker blue cells contain a wall. One maze is connected from top-left to bottom-right (indicated in", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 161, + 505, + 175 + ], + "spans": [ + { + "bbox": [ + 105, + 161, + 505, + 175 + ], + "score": 1.0, + "content": "black), the other is not. Right: An example trajectory in the pool domain (before downsampling).", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 173, + 448, + 185 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 448, + 185 + ], + "score": 1.0, + "content": "It was selected by maximising the prediction of pocketing balls, using the predictron.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "image", + "bbox": [ + 113, + 187, + 487, + 349 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 113, + 187, + 487, + 349 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 113, + 187, + 487, + 349 + ], + "spans": [ + { + "bbox": [ + 113, + 187, + 487, + 349 + ], + "score": 0.973, + "type": "image", + "image_path": "e602264f049e19e6be76364d251d62f7e9f44ac88523eb8c4214db23eff3de07.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 113, + 187, + 487, + 241.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 113, + 241.0, + 487, + 295.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 113, + 295.0, + 487, + 349.0 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 354, + 505, + 409 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 353, + 505, + 367 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 505, + 367 + ], + "score": 1.0, + "content": "Figure 3: Exploring predictron variants. Aggregated prediction errors over all predictions (20", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 364, + 505, + 377 + ], + "spans": [ + { + "bbox": [ + 106, + 364, + 505, + 377 + ], + "score": 1.0, + "content": "for mazes, 280 for pool) for the eight predictron variants corresponding to the cube on the left (as", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 375, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 375, + 505, + 388 + ], + "score": 1.0, + "content": "described in the main text), for both random mazes (top) and pool (bottom). Each line is the median", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 385, + 505, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 403, + 399 + ], + "score": 1.0, + "content": "of RMSE over five seeds; shaded regions encompass all seeds. The full", + "type": "text" + }, + { + "bbox": [ + 403, + 387, + 435, + 399 + ], + "score": 0.92, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 436, + 385, + 505, + 399 + ], + "score": 1.0, + "content": "-prediction (red)", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 397, + 221, + 410 + ], + "spans": [ + { + "bbox": [ + 106, + 397, + 221, + 410 + ], + "score": 1.0, + "content": "consistently performed best.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12 + } + ], + "index": 10.0 + }, + { + "type": "text", + "bbox": [ + 107, + 416, + 505, + 472 + ], + "lines": [], + "index": 17, + "bbox_fs": [ + 105, + 416, + 506, + 473 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 107, + 483, + 331, + 494 + ], + "lines": [ + { + "bbox": [ + 106, + 483, + 332, + 496 + ], + "spans": [ + { + "bbox": [ + 106, + 483, + 332, + 496 + ], + "score": 1.0, + "content": "5.1 EXPLORING THE PREDICTRON ARCHITECTURE", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 108, + 501, + 505, + 534 + ], + "lines": [ + { + "bbox": [ + 105, + 500, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 505, + 514 + ], + "score": 1.0, + "content": "Our first set of experiments examines three binary dimensions that differentiate the predictron from", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 512, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 505, + 524 + ], + "score": 1.0, + "content": "standard deep networks. We compare eight predictron variants corresponding to the corners of the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 523, + 220, + 535 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 220, + 535 + ], + "score": 1.0, + "content": "cube on the left in Figure 3.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22, + "bbox_fs": [ + 105, + 500, + 505, + 535 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 537, + 505, + 581 + ], + "lines": [ + { + "bbox": [ + 105, + 536, + 506, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 506, + 549 + ], + "score": 1.0, + "content": "The first dimension corresponds to whether or not the predictron architecture utilises the structure of", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 547, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 279, + 560 + ], + "score": 1.0, + "content": "an MRP model. In the MRP case, labelled", + "type": "text" + }, + { + "bbox": [ + 280, + 549, + 295, + 559 + ], + "score": 0.87, + "content": "r , \\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 547, + 505, + 560 + ], + "score": 1.0, + "content": ", internal rewards and discounts are both learned. In", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 559, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 106, + 559, + 140, + 571 + ], + "score": 1.0, + "content": "the non-", + "type": "text" + }, + { + "bbox": [ + 140, + 562, + 145, + 569 + ], + "score": 0.64, + "content": "r", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 559, + 148, + 571 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 148, + 561, + 156, + 570 + ], + "score": 0.72, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 156, + 559, + 505, + 571 + ], + "score": 1.0, + "content": "case, which corresponds to a vanilla hidden-to-hidden neural network module, internal", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 569, + 425, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 341, + 581 + ], + "score": 1.0, + "content": "rewards and discounts are ignored by fixing their values to", + "type": "text" + }, + { + "bbox": [ + 342, + 569, + 372, + 580 + ], + "score": 0.92, + "content": "\\mathbf { r } ^ { k } = \\mathbf { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 569, + 389, + 581 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 389, + 569, + 420, + 581 + ], + "score": 0.92, + "content": "\\gamma ^ { k } = \\mathbf { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 421, + 569, + 425, + 581 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25.5, + "bbox_fs": [ + 105, + 536, + 506, + 581 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 583, + 505, + 628 + ], + "lines": [ + { + "bbox": [ + 105, + 583, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 249, + 595 + ], + "score": 1.0, + "content": "The second dimension is whether a", + "type": "text" + }, + { + "bbox": [ + 249, + 583, + 260, + 594 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 583, + 343, + 595 + ], + "score": 1.0, + "content": "-step accumulator or", + "type": "text" + }, + { + "bbox": [ + 343, + 583, + 350, + 594 + ], + "score": 0.8, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 583, + 505, + 595 + ], + "score": 1.0, + "content": "-accumulator is used to aggregate over", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 595, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 178, + 606 + ], + "score": 1.0, + "content": "preturns. When a", + "type": "text" + }, + { + "bbox": [ + 179, + 595, + 186, + 605 + ], + "score": 0.77, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 595, + 279, + 606 + ], + "score": 1.0, + "content": "-accumulator is used, a", + "type": "text" + }, + { + "bbox": [ + 279, + 595, + 286, + 605 + ], + "score": 0.77, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 287, + 595, + 505, + 606 + ], + "score": 1.0, + "content": "-preturn is computed as described in Section 3. Other-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 605, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 361, + 617 + ], + "score": 1.0, + "content": "wise, intermediate preturns are ignored by fixing their values to", + "type": "text" + }, + { + "bbox": [ + 361, + 605, + 392, + 615 + ], + "score": 0.91, + "content": "\\lambda ^ { k } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 605, + 407, + 617 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 407, + 605, + 436, + 615 + ], + "score": 0.91, + "content": "k < K", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 605, + 505, + 617 + ], + "score": 1.0, + "content": ". In this case, the", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 103, + 615, + 405, + 630 + ], + "spans": [ + { + "bbox": [ + 103, + 615, + 386, + 630 + ], + "score": 1.0, + "content": "overall output of the predictron is simply the maximum-depth preturn", + "type": "text" + }, + { + "bbox": [ + 386, + 616, + 401, + 628 + ], + "score": 0.88, + "content": "\\mathbf { g } ^ { K }", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 615, + 405, + 630 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5, + "bbox_fs": [ + 103, + 583, + 505, + 630 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 630, + 505, + 696 + ], + "lines": [ + { + "bbox": [ + 105, + 629, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 505, + 642 + ], + "score": 1.0, + "content": "The third dimension, labelled usage weighting, defines the loss that is used to update the parameters", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 107, + 640, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 107, + 641, + 114, + 651 + ], + "score": 0.57, + "content": "\\pmb \\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 640, + 505, + 653 + ], + "score": 1.0, + "content": ". On this dimension, we consider two options: the preturn losses can either be weighted uniformly", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 651, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 296, + 664 + ], + "score": 1.0, + "content": "(see Equation 6), or the update for each preturn", + "type": "text" + }, + { + "bbox": [ + 296, + 651, + 308, + 663 + ], + "score": 0.91, + "content": "\\mathbf { g } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 651, + 471, + 664 + ], + "score": 1.0, + "content": "can be weighted according to the weight", + "type": "text" + }, + { + "bbox": [ + 472, + 651, + 486, + 662 + ], + "score": 0.89, + "content": "\\boldsymbol { w } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 651, + 506, + 664 + ], + "score": 1.0, + "content": "that", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 661, + 506, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 661, + 263, + 676 + ], + "score": 1.0, + "content": "determines how much it is used in the", + "type": "text" + }, + { + "bbox": [ + 263, + 663, + 271, + 673 + ], + "score": 0.8, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 661, + 506, + 676 + ], + "score": 1.0, + "content": "-predictron’s overall output. We call the latter loss ‘usage", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 672, + 507, + 687 + ], + "spans": [ + { + "bbox": [ + 105, + 672, + 300, + 687 + ], + "score": 1.0, + "content": "weighted‘. Note that for architectures without a", + "type": "text" + }, + { + "bbox": [ + 301, + 675, + 308, + 684 + ], + "score": 0.81, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 672, + 364, + 687 + ], + "score": 1.0, + "content": "-accumulator,", + "type": "text" + }, + { + "bbox": [ + 364, + 673, + 398, + 684 + ], + "score": 0.92, + "content": "\\bar { \\boldsymbol { w } } ^ { k } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 398, + 672, + 413, + 687 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 414, + 674, + 443, + 684 + ], + "score": 0.9, + "content": "k < K", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 672, + 464, + 687 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 465, + 673, + 501, + 684 + ], + "score": 0.91, + "content": "\\mathbf { \\Delta } w ^ { K } = \\mathbf { \\bar { \\mu } }", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 672, + 507, + 687 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 682, + 464, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 444, + 699 + ], + "score": 1.0, + "content": "thus usage weighting then implies backpropagating only the loss on the final preturn", + "type": "text" + }, + { + "bbox": [ + 445, + 684, + 459, + 696 + ], + "score": 0.89, + "content": "\\mathbf { g } ^ { K }", + "type": "inline_equation" + }, + { + "bbox": [ + 460, + 682, + 464, + 699 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 629, + 507, + 699 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "All variants utilise a convolutional core with 2 intermediate hidden layers (see Appendix A); param-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 340, + 721 + ], + "score": 1.0, + "content": "eters were updated by supervised learning (see Appendix", + "type": "text" + }, + { + "bbox": [ + 340, + 710, + 348, + 720 + ], + "score": 0.3, + "content": "\\mathbf { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 709, + 505, + 721 + ], + "score": 1.0, + "content": "for more details). Root mean squared", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "prediction errors for each architecture, aggregated over all predictions, are shown in Figure 3. The", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 327, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 505, + 340 + ], + "score": 1.0, + "content": "top row corresponds to the random mazes and the bottom row to the pool domain. The main con-", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 338, + 505, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 338, + 462, + 350 + ], + "score": 1.0, + "content": "clusion is that learning an MRP model improved performance greatly. The inclusion of", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 462, + 338, + 470, + 348 + ], + "score": 0.74, + "content": "\\lambda", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 470, + 338, + 505, + 350 + ], + "score": 1.0, + "content": "weights", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 348, + 442, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 442, + 362 + ], + "score": 1.0, + "content": "helped as well, especially on pool. Usage weighting further improved performance.", + "type": "text", + "cross_page": true + } + ], + "index": 10 + } + ], + "index": 39, + "bbox_fs": [ + 105, + 698, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 85, + 497, + 249 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 85, + 497, + 249 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 85, + 497, + 249 + ], + "spans": [ + { + "bbox": [ + 106, + 85, + 497, + 249 + ], + "score": 0.969, + "type": "image", + "image_path": "dba61ef00d493777d067bc381985a11c743383fcb9df81dc1d0a496239d6428e.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 85, + 497, + 139.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 139.66666666666666, + 497, + 194.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 194.33333333333331, + 497, + 248.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 263, + 505, + 319 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 263, + 505, + 277 + ], + "spans": [ + { + "bbox": [ + 104, + 263, + 505, + 277 + ], + "score": 1.0, + "content": "Figure 4: Comparing predictron to baselines. Aggregated prediction errors on random mazes", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 274, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 274, + 505, + 288 + ], + "score": 1.0, + "content": "(top) and pool (bottom) over all predictions for the eight architectures corresponding to the cube on", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 284, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 505, + 299 + ], + "score": 1.0, + "content": "the left. Each line is the median of RMSE over five seeds; shaded regions encompass all seeds. The", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 295, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 124, + 310 + ], + "score": 1.0, + "content": "full", + "type": "text" + }, + { + "bbox": [ + 124, + 296, + 157, + 308 + ], + "score": 0.92, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 295, + 505, + 310 + ], + "score": 1.0, + "content": "-predictron (red), consistently outperformed conventional deep network architectures", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 306, + 385, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 385, + 321 + ], + "score": 1.0, + "content": "(black), with and without skips and with and without weight sharing.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5 + } + ], + "index": 3.0 + }, + { + "type": "text", + "bbox": [ + 107, + 327, + 505, + 361 + ], + "lines": [ + { + "bbox": [ + 105, + 327, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 505, + 340 + ], + "score": 1.0, + "content": "top row corresponds to the random mazes and the bottom row to the pool domain. The main con-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 338, + 505, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 338, + 462, + 350 + ], + "score": 1.0, + "content": "clusion is that learning an MRP model improved performance greatly. The inclusion of", + "type": "text" + }, + { + "bbox": [ + 462, + 338, + 470, + 348 + ], + "score": 0.74, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 338, + 505, + 350 + ], + "score": 1.0, + "content": "weights", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 348, + 442, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 442, + 362 + ], + "score": 1.0, + "content": "helped as well, especially on pool. Usage weighting further improved performance.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + }, + { + "type": "title", + "bbox": [ + 107, + 372, + 387, + 384 + ], + "lines": [ + { + "bbox": [ + 105, + 371, + 388, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 388, + 385 + ], + "score": 1.0, + "content": "5.2 COMPARING THE PREDICTRON TO OTHER DEEP NETWORKS", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 108, + 390, + 504, + 424 + ], + "lines": [ + { + "bbox": [ + 105, + 389, + 505, + 404 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 505, + 404 + ], + "score": 1.0, + "content": "Our second set of experiments compares the predictron to feedforward and recurrent deep learning", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "score": 1.0, + "content": "architectures, with and without skip connections. We compare the corners of a new cube, as depicted", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 412, + 374, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 412, + 374, + 426 + ], + "score": 1.0, + "content": "on the left in Figure 4, based on three different binary dimensions.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 426, + 505, + 470 + ], + "lines": [ + { + "bbox": [ + 105, + 425, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 434, + 439 + ], + "score": 1.0, + "content": "The first dimension of this second cube is whether we use a predictron, or a (non-", + "type": "text" + }, + { + "bbox": [ + 434, + 427, + 441, + 436 + ], + "score": 0.69, + "content": "\\boldsymbol { \\cdot } \\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 441, + 425, + 463, + 439 + ], + "score": 1.0, + "content": ", non-", + "type": "text" + }, + { + "bbox": [ + 463, + 428, + 479, + 438 + ], + "score": 0.33, + "content": "\\cdot r , \\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 425, + 505, + 439 + ], + "score": 1.0, + "content": ") deep", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 437, + 504, + 449 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 504, + 449 + ], + "score": 1.0, + "content": "network that does not have an internal model and does not output or learn from intermediate predic-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 447, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 426, + 461 + ], + "score": 1.0, + "content": "tions. We use the most effective predictron from the previous section, i.e., the", + "type": "text" + }, + { + "bbox": [ + 426, + 448, + 459, + 460 + ], + "score": 0.92, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 460, + 447, + 505, + 461 + ], + "score": 1.0, + "content": "-predictron", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 458, + 197, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 197, + 473 + ], + "score": 1.0, + "content": "with usage weighting.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 16.5 + }, + { + "type": "text", + "bbox": [ + 107, + 473, + 505, + 517 + ], + "lines": [ + { + "bbox": [ + 106, + 473, + 505, + 485 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 505, + 485 + ], + "score": 1.0, + "content": "The second dimension is whether weights are shared between all cores (as in a recurrent network),", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 484, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 505, + 495 + ], + "score": 1.0, + "content": "or whether each core uses separate weights (as in a feedforward network). We note that the non-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 495, + 505, + 508 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 114, + 505 + ], + "score": 0.72, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 495, + 136, + 508 + ], + "score": 1.0, + "content": ", non-", + "type": "text" + }, + { + "bbox": [ + 136, + 497, + 153, + 507 + ], + "score": 0.63, + "content": "\\cdot r , \\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 153, + 495, + 505, + 508 + ], + "score": 1.0, + "content": "variants of the predictron then correspond to standard (convolutional) feedforward and", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 506, + 306, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 306, + 519 + ], + "score": 1.0, + "content": "(unrolled) recurrent neural networks respectively.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 107, + 519, + 505, + 564 + ], + "lines": [ + { + "bbox": [ + 105, + 519, + 505, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 519, + 505, + 532 + ], + "score": 1.0, + "content": "The third dimension is whether we include skip connections. This is equivalent to defining the model", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 528, + 504, + 543 + ], + "spans": [ + { + "bbox": [ + 104, + 528, + 284, + 543 + ], + "score": 1.0, + "content": "step to output a change to the current state,", + "type": "text" + }, + { + "bbox": [ + 284, + 531, + 299, + 541 + ], + "score": 0.75, + "content": "\\Delta \\mathbf { s } .", + "type": "inline_equation" + }, + { + "bbox": [ + 299, + 528, + 375, + 543 + ], + "score": 1.0, + "content": ", and then defining", + "type": "text" + }, + { + "bbox": [ + 375, + 530, + 465, + 542 + ], + "score": 0.92, + "content": "\\mathbf { s } ^ { \\hat { k } + 1 } = h ( \\mathbf { s } ^ { k } + \\Delta \\mathbf { s } ^ { \\tilde { k } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 465, + 528, + 496, + 543 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 497, + 531, + 504, + 541 + ], + "score": 0.76, + "content": "h", + "type": "inline_equation" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 540, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 305, + 555 + ], + "score": 1.0, + "content": "is the non-linear function—in our case a ReLU,", + "type": "text" + }, + { + "bbox": [ + 305, + 541, + 381, + 554 + ], + "score": 0.91, + "content": "h ( x ) = \\operatorname* { m a x } ( \\bar { 0 , x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 540, + 505, + 555 + ], + "score": 1.0, + "content": ". The deep network with skip", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 553, + 315, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 553, + 315, + 564 + ], + "score": 1.0, + "content": "connections is a variant of ResNet (He et al., 2015).", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 107, + 566, + 505, + 622 + ], + "lines": [ + { + "bbox": [ + 105, + 566, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 467, + 579 + ], + "score": 1.0, + "content": "Root mean squared prediction errors for each architecture are shown in Figure 4. All", + "type": "text" + }, + { + "bbox": [ + 468, + 566, + 500, + 578 + ], + "score": 0.91, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 566, + 505, + 579 + ], + "score": 1.0, + "content": "-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 577, + 505, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 505, + 589 + ], + "score": 1.0, + "content": "predictrons (red lines) outperformed the corresponding feedforward or recurrent neural network", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 588, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 506, + 601 + ], + "score": 1.0, + "content": "baselines (black lines) both in the random mazes and in pool. We also investigated the effect of", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "changing the depth of the networks (see Appendix C). The predictron outperformed the correspond-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 610, + 460, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 460, + 623 + ], + "score": 1.0, + "content": "ing feedforward or recurrent baselines for all depths, with and without skip connections.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29 + }, + { + "type": "title", + "bbox": [ + 107, + 634, + 334, + 645 + ], + "lines": [ + { + "bbox": [ + 105, + 633, + 336, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 336, + 646 + ], + "score": 1.0, + "content": "5.3 SEMI-SUPERVISED LEARNING BY CONSISTENCY", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 652, + 505, + 696 + ], + "lines": [ + { + "bbox": [ + 106, + 652, + 504, + 664 + ], + "spans": [ + { + "bbox": [ + 106, + 652, + 504, + 664 + ], + "score": 1.0, + "content": "We now consider how to use the predictron for semi-supervised learning, training the model on", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 663, + 506, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 506, + 675 + ], + "score": 1.0, + "content": "a combination of labelled and unlabelled random mazes. Semi-supervised learning is important", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 675, + 506, + 686 + ], + "spans": [ + { + "bbox": [ + 105, + 675, + 506, + 686 + ], + "score": 1.0, + "content": "because a common bottleneck in applying machine learning in the real world is the difficulty of", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 685, + 423, + 697 + ], + "spans": [ + { + "bbox": [ + 106, + 685, + 423, + 697 + ], + "score": 1.0, + "content": "collecting labelled data, whereas often large quantities of unlabelled data exist.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34.5 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 697, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 179, + 713 + ], + "score": 1.0, + "content": "We trained a full", + "type": "text" + }, + { + "bbox": [ + 180, + 698, + 212, + 711 + ], + "score": 0.92, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 697, + 505, + 713 + ], + "score": 1.0, + "content": "-predictron by alternating standard supervised updates with consistency", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "updates, obtained by stochastically minimizing the consistency loss (8), on the unlabelled samples.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "For each supervised update we apply either 0, 1, or 9 consistency updates. Figure 5 shows that", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "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" + } + ] + } + ] + }, + { + "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" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 85, + 497, + 249 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 85, + 497, + 249 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 85, + 497, + 249 + ], + "spans": [ + { + "bbox": [ + 106, + 85, + 497, + 249 + ], + "score": 0.969, + "type": "image", + "image_path": "dba61ef00d493777d067bc381985a11c743383fcb9df81dc1d0a496239d6428e.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 85, + 497, + 139.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 139.66666666666666, + 497, + 194.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 194.33333333333331, + 497, + 248.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 263, + 505, + 319 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 263, + 505, + 277 + ], + "spans": [ + { + "bbox": [ + 104, + 263, + 505, + 277 + ], + "score": 1.0, + "content": "Figure 4: Comparing predictron to baselines. Aggregated prediction errors on random mazes", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 274, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 274, + 505, + 288 + ], + "score": 1.0, + "content": "(top) and pool (bottom) over all predictions for the eight architectures corresponding to the cube on", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 284, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 505, + 299 + ], + "score": 1.0, + "content": "the left. Each line is the median of RMSE over five seeds; shaded regions encompass all seeds. The", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 295, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 124, + 310 + ], + "score": 1.0, + "content": "full", + "type": "text" + }, + { + "bbox": [ + 124, + 296, + 157, + 308 + ], + "score": 0.92, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 295, + 505, + 310 + ], + "score": 1.0, + "content": "-predictron (red), consistently outperformed conventional deep network architectures", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 306, + 385, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 385, + 321 + ], + "score": 1.0, + "content": "(black), with and without skips and with and without weight sharing.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5 + } + ], + "index": 3.0 + }, + { + "type": "text", + "bbox": [ + 107, + 327, + 505, + 361 + ], + "lines": [], + "index": 9, + "bbox_fs": [ + 105, + 327, + 505, + 362 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 107, + 372, + 387, + 384 + ], + "lines": [ + { + "bbox": [ + 105, + 371, + 388, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 388, + 385 + ], + "score": 1.0, + "content": "5.2 COMPARING THE PREDICTRON TO OTHER DEEP NETWORKS", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 108, + 390, + 504, + 424 + ], + "lines": [ + { + "bbox": [ + 105, + 389, + 505, + 404 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 505, + 404 + ], + "score": 1.0, + "content": "Our second set of experiments compares the predictron to feedforward and recurrent deep learning", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "score": 1.0, + "content": "architectures, with and without skip connections. We compare the corners of a new cube, as depicted", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 412, + 374, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 412, + 374, + 426 + ], + "score": 1.0, + "content": "on the left in Figure 4, based on three different binary dimensions.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13, + "bbox_fs": [ + 105, + 389, + 505, + 426 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 426, + 505, + 470 + ], + "lines": [ + { + "bbox": [ + 105, + 425, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 434, + 439 + ], + "score": 1.0, + "content": "The first dimension of this second cube is whether we use a predictron, or a (non-", + "type": "text" + }, + { + "bbox": [ + 434, + 427, + 441, + 436 + ], + "score": 0.69, + "content": "\\boldsymbol { \\cdot } \\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 441, + 425, + 463, + 439 + ], + "score": 1.0, + "content": ", non-", + "type": "text" + }, + { + "bbox": [ + 463, + 428, + 479, + 438 + ], + "score": 0.33, + "content": "\\cdot r , \\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 425, + 505, + 439 + ], + "score": 1.0, + "content": ") deep", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 437, + 504, + 449 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 504, + 449 + ], + "score": 1.0, + "content": "network that does not have an internal model and does not output or learn from intermediate predic-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 447, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 426, + 461 + ], + "score": 1.0, + "content": "tions. We use the most effective predictron from the previous section, i.e., the", + "type": "text" + }, + { + "bbox": [ + 426, + 448, + 459, + 460 + ], + "score": 0.92, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 460, + 447, + 505, + 461 + ], + "score": 1.0, + "content": "-predictron", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 458, + 197, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 197, + 473 + ], + "score": 1.0, + "content": "with usage weighting.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 16.5, + "bbox_fs": [ + 105, + 425, + 505, + 473 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 473, + 505, + 517 + ], + "lines": [ + { + "bbox": [ + 106, + 473, + 505, + 485 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 505, + 485 + ], + "score": 1.0, + "content": "The second dimension is whether weights are shared between all cores (as in a recurrent network),", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 484, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 505, + 495 + ], + "score": 1.0, + "content": "or whether each core uses separate weights (as in a feedforward network). We note that the non-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 495, + 505, + 508 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 114, + 505 + ], + "score": 0.72, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 495, + 136, + 508 + ], + "score": 1.0, + "content": ", non-", + "type": "text" + }, + { + "bbox": [ + 136, + 497, + 153, + 507 + ], + "score": 0.63, + "content": "\\cdot r , \\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 153, + 495, + 505, + 508 + ], + "score": 1.0, + "content": "variants of the predictron then correspond to standard (convolutional) feedforward and", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 506, + 306, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 306, + 519 + ], + "score": 1.0, + "content": "(unrolled) recurrent neural networks respectively.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5, + "bbox_fs": [ + 105, + 473, + 505, + 519 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 519, + 505, + 564 + ], + "lines": [ + { + "bbox": [ + 105, + 519, + 505, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 519, + 505, + 532 + ], + "score": 1.0, + "content": "The third dimension is whether we include skip connections. This is equivalent to defining the model", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 528, + 504, + 543 + ], + "spans": [ + { + "bbox": [ + 104, + 528, + 284, + 543 + ], + "score": 1.0, + "content": "step to output a change to the current state,", + "type": "text" + }, + { + "bbox": [ + 284, + 531, + 299, + 541 + ], + "score": 0.75, + "content": "\\Delta \\mathbf { s } .", + "type": "inline_equation" + }, + { + "bbox": [ + 299, + 528, + 375, + 543 + ], + "score": 1.0, + "content": ", and then defining", + "type": "text" + }, + { + "bbox": [ + 375, + 530, + 465, + 542 + ], + "score": 0.92, + "content": "\\mathbf { s } ^ { \\hat { k } + 1 } = h ( \\mathbf { s } ^ { k } + \\Delta \\mathbf { s } ^ { \\tilde { k } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 465, + 528, + 496, + 543 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 497, + 531, + 504, + 541 + ], + "score": 0.76, + "content": "h", + "type": "inline_equation" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 540, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 305, + 555 + ], + "score": 1.0, + "content": "is the non-linear function—in our case a ReLU,", + "type": "text" + }, + { + "bbox": [ + 305, + 541, + 381, + 554 + ], + "score": 0.91, + "content": "h ( x ) = \\operatorname* { m a x } ( \\bar { 0 , x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 540, + 505, + 555 + ], + "score": 1.0, + "content": ". The deep network with skip", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 553, + 315, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 553, + 315, + 564 + ], + "score": 1.0, + "content": "connections is a variant of ResNet (He et al., 2015).", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 24.5, + "bbox_fs": [ + 104, + 519, + 505, + 564 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 566, + 505, + 622 + ], + "lines": [ + { + "bbox": [ + 105, + 566, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 467, + 579 + ], + "score": 1.0, + "content": "Root mean squared prediction errors for each architecture are shown in Figure 4. All", + "type": "text" + }, + { + "bbox": [ + 468, + 566, + 500, + 578 + ], + "score": 0.91, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 566, + 505, + 579 + ], + "score": 1.0, + "content": "-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 577, + 505, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 505, + 589 + ], + "score": 1.0, + "content": "predictrons (red lines) outperformed the corresponding feedforward or recurrent neural network", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 588, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 506, + 601 + ], + "score": 1.0, + "content": "baselines (black lines) both in the random mazes and in pool. We also investigated the effect of", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "changing the depth of the networks (see Appendix C). The predictron outperformed the correspond-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 610, + 460, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 460, + 623 + ], + "score": 1.0, + "content": "ing feedforward or recurrent baselines for all depths, with and without skip connections.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29, + "bbox_fs": [ + 105, + 566, + 506, + 623 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 634, + 334, + 645 + ], + "lines": [ + { + "bbox": [ + 105, + 633, + 336, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 336, + 646 + ], + "score": 1.0, + "content": "5.3 SEMI-SUPERVISED LEARNING BY CONSISTENCY", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 652, + 505, + 696 + ], + "lines": [ + { + "bbox": [ + 106, + 652, + 504, + 664 + ], + "spans": [ + { + "bbox": [ + 106, + 652, + 504, + 664 + ], + "score": 1.0, + "content": "We now consider how to use the predictron for semi-supervised learning, training the model on", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 663, + 506, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 506, + 675 + ], + "score": 1.0, + "content": "a combination of labelled and unlabelled random mazes. Semi-supervised learning is important", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 675, + 506, + 686 + ], + "spans": [ + { + "bbox": [ + 105, + 675, + 506, + 686 + ], + "score": 1.0, + "content": "because a common bottleneck in applying machine learning in the real world is the difficulty of", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 685, + 423, + 697 + ], + "spans": [ + { + "bbox": [ + 106, + 685, + 423, + 697 + ], + "score": 1.0, + "content": "collecting labelled data, whereas often large quantities of unlabelled data exist.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 652, + 506, + 697 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 697, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 179, + 713 + ], + "score": 1.0, + "content": "We trained a full", + "type": "text" + }, + { + "bbox": [ + 180, + 698, + 212, + 711 + ], + "score": 0.92, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 697, + 505, + 713 + ], + "score": 1.0, + "content": "-predictron by alternating standard supervised updates with consistency", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "updates, obtained by stochastically minimizing the consistency loss (8), on the unlabelled samples.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "For each supervised update we apply either 0, 1, or 9 consistency updates. Figure 5 shows that", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 81, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 506, + 96 + ], + "score": 1.0, + "content": "the performance improved monotonically with the number of consistency updates, measured as a", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 325, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 325, + 105 + ], + "score": 1.0, + "content": "function of the number of labelled samples consumed.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 697, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 506, + 96 + ], + "score": 1.0, + "content": "the performance improved monotonically with the number of consistency updates, measured as a", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 325, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 325, + 105 + ], + "score": 1.0, + "content": "function of the number of labelled samples consumed.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "image", + "bbox": [ + 151, + 122, + 456, + 230 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 151, + 122, + 456, + 230 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 151, + 122, + 456, + 230 + ], + "spans": [ + { + "bbox": [ + 151, + 122, + 456, + 230 + ], + "score": 0.968, + "type": "image", + "image_path": "a6a297ad344d3d9b89961b40f0a239cf9bf15e8964e2525c883b866251e3e396.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 151, + 122, + 456, + 158.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 151, + 158.0, + 456, + 194.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 151, + 194.0, + 456, + 230.0 + ], + "spans": [], + "index": 4 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 239, + 505, + 272 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 238, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 355, + 252 + ], + "score": 1.0, + "content": "Figure 5: Semi-supervised learning. Prediction errors of the", + "type": "text" + }, + { + "bbox": [ + 356, + 239, + 388, + 250 + ], + "score": 0.92, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 238, + 505, + 252 + ], + "score": 1.0, + "content": "-predictrons (shared core, no", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 250, + 505, + 262 + ], + "spans": [ + { + "bbox": [ + 106, + 250, + 505, + 262 + ], + "score": 1.0, + "content": "skips) using 0, 1, or 9 consistency updates for every update with labelled data, plotted as function of", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 259, + 495, + 273 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 495, + 273 + ], + "score": 1.0, + "content": "the number of labels consumed. Learning performance improves with more consistency updates.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + } + ], + "index": 4.5 + }, + { + "type": "title", + "bbox": [ + 108, + 295, + 265, + 305 + ], + "lines": [ + { + "bbox": [ + 106, + 294, + 267, + 306 + ], + "spans": [ + { + "bbox": [ + 106, + 294, + 267, + 306 + ], + "score": 1.0, + "content": "5.4 ANALYSIS OF ADAPTIVE DEPTH", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 312, + 505, + 433 + ], + "lines": [ + { + "bbox": [ + 105, + 312, + 505, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 312, + 505, + 325 + ], + "score": 1.0, + "content": "In principle, the predictron can adapt its depth to ‘think more’ about some predictions than others,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 322, + 506, + 336 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 506, + 336 + ], + "score": 1.0, + "content": "perhaps depending on the complexity of the underlying target. We investigate this by looking at", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 334, + 506, + 346 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 506, + 346 + ], + "score": 1.0, + "content": "qualitatively different prediction types in pool: ball collisions, rail collisions, pocketing balls, and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 345, + 505, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 505, + 358 + ], + "score": 1.0, + "content": "entering or staying in quadrants. For each prediction type we consider several different time-spans", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 356, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 106, + 356, + 505, + 368 + ], + "score": 1.0, + "content": "(determined by the real-world discount factors associated with each pseudo-reward). Figure 6 shows", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 367, + 506, + 379 + ], + "spans": [ + { + "bbox": [ + 106, + 367, + 506, + 379 + ], + "score": 1.0, + "content": "distributions of depth for each type of prediction. The ‘depth’ of a predictron is here defined as the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 377, + 506, + 390 + ], + "spans": [ + { + "bbox": [ + 105, + 377, + 466, + 390 + ], + "score": 1.0, + "content": "effective number of model steps. If the predictron relies fully on the very first value (i.e.,", + "type": "text" + }, + { + "bbox": [ + 466, + 377, + 498, + 388 + ], + "score": 0.89, + "content": "\\lambda ^ { 0 } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 499, + 377, + 506, + 390 + ], + "score": 1.0, + "content": "),", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 389, + 505, + 401 + ], + "spans": [ + { + "bbox": [ + 106, + 389, + 505, + 401 + ], + "score": 1.0, + "content": "this counts as 0 steps. If, instead, it learns to place equal weight on all rewards and on the final", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 399, + 506, + 412 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 317, + 412 + ], + "score": 1.0, + "content": "value, this counts as 16 steps. Concretely, the depth", + "type": "text" + }, + { + "bbox": [ + 317, + 400, + 325, + 410 + ], + "score": 0.67, + "content": "^ d", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 399, + 444, + 412 + ], + "score": 1.0, + "content": "can be defined recursively as", + "type": "text" + }, + { + "bbox": [ + 445, + 399, + 477, + 410 + ], + "score": 0.92, + "content": "\\pmb { d } = \\pmb { d } ^ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 399, + 506, + 412 + ], + "score": 1.0, + "content": "where", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 107, + 408, + 507, + 425 + ], + "spans": [ + { + "bbox": [ + 107, + 410, + 200, + 423 + ], + "score": 0.91, + "content": "\\pmb { d } ^ { k } = \\lambda ^ { k } ( 1 + \\gamma ^ { k } \\pmb { d } ^ { k + 1 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 200, + 408, + 219, + 425 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 219, + 410, + 254, + 421 + ], + "score": 0.92, + "content": "\\mathbf { { \\mathbf { { \\mathbf { { \\mathbf { { \\mathbf { \\alpha } } } } } } } } } \\mathbf { { \\mathbf { { \\mathbf { { d } } } } } } ^ { K } = \\mathbf { { \\mathbf { 0 } } }", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 408, + 507, + 425 + ], + "score": 1.0, + "content": ". Note that even for the same input state, each prediction has a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 421, + 169, + 435 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 169, + 435 + ], + "score": 1.0, + "content": "separate depth.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 106, + 435, + 505, + 501 + ], + "lines": [ + { + "bbox": [ + 106, + 434, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 106, + 434, + 505, + 447 + ], + "score": 1.0, + "content": "The depth distributions exhibit three properties. First, different types of predictions used different", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 446, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 505, + 460 + ], + "score": 1.0, + "content": "depths. Second, depth was correlated with the real-world discount for the first four prediction types.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 456, + 506, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 506, + 470 + ], + "score": 1.0, + "content": "Third, the distributions are not strongly peaked, which implies that the depth can differ per input", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 468, + 505, + 481 + ], + "spans": [ + { + "bbox": [ + 105, + 468, + 505, + 481 + ], + "score": 1.0, + "content": "even for a single real-world discount and prediction type. In a control experiment (not shown) we", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 478, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 159, + 492 + ], + "score": 1.0, + "content": "used a scalar", + "type": "text" + }, + { + "bbox": [ + 159, + 480, + 166, + 489 + ], + "score": 0.75, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 478, + 506, + 492 + ], + "score": 1.0, + "content": "shared among all predictions, which reduced performance in all scenarios, indicating", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 490, + 351, + 503 + ], + "spans": [ + { + "bbox": [ + 106, + 490, + 351, + 503 + ], + "score": 1.0, + "content": "that the heterogeneous depth is a valuable form of flexibility.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22.5 + }, + { + "type": "title", + "bbox": [ + 107, + 514, + 363, + 524 + ], + "lines": [ + { + "bbox": [ + 105, + 513, + 364, + 526 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 364, + 526 + ], + "score": 1.0, + "content": "5.5 VISUALIZING THE PREDICTIONS IN THE POOL DOMAIN", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 531, + 505, + 587 + ], + "lines": [ + { + "bbox": [ + 106, + 531, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 505, + 543 + ], + "score": 1.0, + "content": "We test the quality of the predictions in the pool domain to evaluate whether they are well-suited to", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 542, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 542, + 380, + 554 + ], + "score": 1.0, + "content": "making decisions. For each sampled pool position, we consider a set", + "type": "text" + }, + { + "bbox": [ + 381, + 543, + 388, + 552 + ], + "score": 0.71, + "content": "I", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 542, + 505, + 554 + ], + "score": 1.0, + "content": "of different initial conditions", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 551, + 506, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 506, + 567 + ], + "score": 1.0, + "content": "(different angles and velocity of the white ball), and ask which is more likely to lead to pocketing", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 563, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 273, + 578 + ], + "score": 1.0, + "content": "coloured balls. For each initial condition", + "type": "text" + }, + { + "bbox": [ + 273, + 565, + 297, + 574 + ], + "score": 0.89, + "content": "s \\in I", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 563, + 355, + 578 + ], + "score": 1.0, + "content": ", we apply the", + "type": "text" + }, + { + "bbox": [ + 356, + 564, + 388, + 576 + ], + "score": 0.93, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 563, + 506, + 578 + ], + "score": 1.0, + "content": "-predictron (shared cores, 16", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 575, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 106, + 575, + 327, + 588 + ], + "score": 1.0, + "content": "model steps, no skip connections) to obtain predictions", + "type": "text" + }, + { + "bbox": [ + 328, + 575, + 340, + 587 + ], + "score": 0.87, + "content": "\\mathbf { g } ^ { \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 575, + 505, + 588 + ], + "score": 1.0, + "content": ". We sum the predictions that correspond", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29 + }, + { + "type": "image", + "bbox": [ + 111, + 610, + 500, + 702 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 111, + 610, + 500, + 702 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 111, + 610, + 500, + 702 + ], + "spans": [ + { + "bbox": [ + 111, + 610, + 500, + 702 + ], + "score": 0.967, + "type": "image", + "image_path": "9e5eda1ba0817010e3a899cfcd39b4555fece7632765839f1302bb06efcfea60.jpg" + } + ] + } + ], + "index": 33, + "virtual_lines": [ + { + "bbox": [ + 111, + 610, + 500, + 640.6666666666666 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 111, + 640.6666666666666, + 500, + 671.3333333333333 + ], + "spans": [], + "index": 33 + }, + { + "bbox": [ + 111, + 671.3333333333333, + 500, + 701.9999999999999 + ], + "spans": [], + "index": 34 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 709, + 504, + 731 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "Figure 6: Thinking depth. Distributions of thinking depth on pool for different types of predictions", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 720, + 261, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 261, + 732 + ], + "score": 1.0, + "content": "and for different real-world discounts.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5 + } + ], + "index": 34.25 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 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": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [], + "index": 0.5, + "bbox_fs": [ + 105, + 81, + 506, + 105 + ], + "lines_deleted": true + }, + { + "type": "image", + "bbox": [ + 151, + 122, + 456, + 230 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 151, + 122, + 456, + 230 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 151, + 122, + 456, + 230 + ], + "spans": [ + { + "bbox": [ + 151, + 122, + 456, + 230 + ], + "score": 0.968, + "type": "image", + "image_path": "a6a297ad344d3d9b89961b40f0a239cf9bf15e8964e2525c883b866251e3e396.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 151, + 122, + 456, + 158.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 151, + 158.0, + 456, + 194.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 151, + 194.0, + 456, + 230.0 + ], + "spans": [], + "index": 4 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 239, + 505, + 272 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 238, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 355, + 252 + ], + "score": 1.0, + "content": "Figure 5: Semi-supervised learning. Prediction errors of the", + "type": "text" + }, + { + "bbox": [ + 356, + 239, + 388, + 250 + ], + "score": 0.92, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 238, + 505, + 252 + ], + "score": 1.0, + "content": "-predictrons (shared core, no", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 250, + 505, + 262 + ], + "spans": [ + { + "bbox": [ + 106, + 250, + 505, + 262 + ], + "score": 1.0, + "content": "skips) using 0, 1, or 9 consistency updates for every update with labelled data, plotted as function of", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 259, + 495, + 273 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 495, + 273 + ], + "score": 1.0, + "content": "the number of labels consumed. Learning performance improves with more consistency updates.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + } + ], + "index": 4.5 + }, + { + "type": "title", + "bbox": [ + 108, + 295, + 265, + 305 + ], + "lines": [ + { + "bbox": [ + 106, + 294, + 267, + 306 + ], + "spans": [ + { + "bbox": [ + 106, + 294, + 267, + 306 + ], + "score": 1.0, + "content": "5.4 ANALYSIS OF ADAPTIVE DEPTH", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 312, + 505, + 433 + ], + "lines": [ + { + "bbox": [ + 105, + 312, + 505, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 312, + 505, + 325 + ], + "score": 1.0, + "content": "In principle, the predictron can adapt its depth to ‘think more’ about some predictions than others,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 322, + 506, + 336 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 506, + 336 + ], + "score": 1.0, + "content": "perhaps depending on the complexity of the underlying target. We investigate this by looking at", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 334, + 506, + 346 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 506, + 346 + ], + "score": 1.0, + "content": "qualitatively different prediction types in pool: ball collisions, rail collisions, pocketing balls, and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 345, + 505, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 505, + 358 + ], + "score": 1.0, + "content": "entering or staying in quadrants. For each prediction type we consider several different time-spans", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 356, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 106, + 356, + 505, + 368 + ], + "score": 1.0, + "content": "(determined by the real-world discount factors associated with each pseudo-reward). Figure 6 shows", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 367, + 506, + 379 + ], + "spans": [ + { + "bbox": [ + 106, + 367, + 506, + 379 + ], + "score": 1.0, + "content": "distributions of depth for each type of prediction. The ‘depth’ of a predictron is here defined as the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 377, + 506, + 390 + ], + "spans": [ + { + "bbox": [ + 105, + 377, + 466, + 390 + ], + "score": 1.0, + "content": "effective number of model steps. If the predictron relies fully on the very first value (i.e.,", + "type": "text" + }, + { + "bbox": [ + 466, + 377, + 498, + 388 + ], + "score": 0.89, + "content": "\\lambda ^ { 0 } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 499, + 377, + 506, + 390 + ], + "score": 1.0, + "content": "),", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 389, + 505, + 401 + ], + "spans": [ + { + "bbox": [ + 106, + 389, + 505, + 401 + ], + "score": 1.0, + "content": "this counts as 0 steps. If, instead, it learns to place equal weight on all rewards and on the final", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 399, + 506, + 412 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 317, + 412 + ], + "score": 1.0, + "content": "value, this counts as 16 steps. Concretely, the depth", + "type": "text" + }, + { + "bbox": [ + 317, + 400, + 325, + 410 + ], + "score": 0.67, + "content": "^ d", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 399, + 444, + 412 + ], + "score": 1.0, + "content": "can be defined recursively as", + "type": "text" + }, + { + "bbox": [ + 445, + 399, + 477, + 410 + ], + "score": 0.92, + "content": "\\pmb { d } = \\pmb { d } ^ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 399, + 506, + 412 + ], + "score": 1.0, + "content": "where", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 107, + 408, + 507, + 425 + ], + "spans": [ + { + "bbox": [ + 107, + 410, + 200, + 423 + ], + "score": 0.91, + "content": "\\pmb { d } ^ { k } = \\lambda ^ { k } ( 1 + \\gamma ^ { k } \\pmb { d } ^ { k + 1 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 200, + 408, + 219, + 425 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 219, + 410, + 254, + 421 + ], + "score": 0.92, + "content": "\\mathbf { { \\mathbf { { \\mathbf { { \\mathbf { { \\mathbf { \\alpha } } } } } } } } } \\mathbf { { \\mathbf { { \\mathbf { { d } } } } } } ^ { K } = \\mathbf { { \\mathbf { 0 } } }", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 408, + 507, + 425 + ], + "score": 1.0, + "content": ". Note that even for the same input state, each prediction has a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 421, + 169, + 435 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 169, + 435 + ], + "score": 1.0, + "content": "separate depth.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 14, + "bbox_fs": [ + 105, + 312, + 507, + 435 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 435, + 505, + 501 + ], + "lines": [ + { + "bbox": [ + 106, + 434, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 106, + 434, + 505, + 447 + ], + "score": 1.0, + "content": "The depth distributions exhibit three properties. First, different types of predictions used different", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 446, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 505, + 460 + ], + "score": 1.0, + "content": "depths. Second, depth was correlated with the real-world discount for the first four prediction types.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 456, + 506, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 506, + 470 + ], + "score": 1.0, + "content": "Third, the distributions are not strongly peaked, which implies that the depth can differ per input", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 468, + 505, + 481 + ], + "spans": [ + { + "bbox": [ + 105, + 468, + 505, + 481 + ], + "score": 1.0, + "content": "even for a single real-world discount and prediction type. In a control experiment (not shown) we", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 478, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 159, + 492 + ], + "score": 1.0, + "content": "used a scalar", + "type": "text" + }, + { + "bbox": [ + 159, + 480, + 166, + 489 + ], + "score": 0.75, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 478, + 506, + 492 + ], + "score": 1.0, + "content": "shared among all predictions, which reduced performance in all scenarios, indicating", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 490, + 351, + 503 + ], + "spans": [ + { + "bbox": [ + 106, + 490, + 351, + 503 + ], + "score": 1.0, + "content": "that the heterogeneous depth is a valuable form of flexibility.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 434, + 506, + 503 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 514, + 363, + 524 + ], + "lines": [ + { + "bbox": [ + 105, + 513, + 364, + 526 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 364, + 526 + ], + "score": 1.0, + "content": "5.5 VISUALIZING THE PREDICTIONS IN THE POOL DOMAIN", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 531, + 505, + 587 + ], + "lines": [ + { + "bbox": [ + 106, + 531, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 505, + 543 + ], + "score": 1.0, + "content": "We test the quality of the predictions in the pool domain to evaluate whether they are well-suited to", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 542, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 542, + 380, + 554 + ], + "score": 1.0, + "content": "making decisions. For each sampled pool position, we consider a set", + "type": "text" + }, + { + "bbox": [ + 381, + 543, + 388, + 552 + ], + "score": 0.71, + "content": "I", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 542, + 505, + 554 + ], + "score": 1.0, + "content": "of different initial conditions", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 551, + 506, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 506, + 567 + ], + "score": 1.0, + "content": "(different angles and velocity of the white ball), and ask which is more likely to lead to pocketing", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 563, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 273, + 578 + ], + "score": 1.0, + "content": "coloured balls. For each initial condition", + "type": "text" + }, + { + "bbox": [ + 273, + 565, + 297, + 574 + ], + "score": 0.89, + "content": "s \\in I", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 563, + 355, + 578 + ], + "score": 1.0, + "content": ", we apply the", + "type": "text" + }, + { + "bbox": [ + 356, + 564, + 388, + 576 + ], + "score": 0.93, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 563, + 506, + 578 + ], + "score": 1.0, + "content": "-predictron (shared cores, 16", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 575, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 106, + 575, + 327, + 588 + ], + "score": 1.0, + "content": "model steps, no skip connections) to obtain predictions", + "type": "text" + }, + { + "bbox": [ + 328, + 575, + 340, + 587 + ], + "score": 0.87, + "content": "\\mathbf { g } ^ { \\lambda }", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 575, + 505, + 588 + ], + "score": 1.0, + "content": ". We sum the predictions that correspond", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 397, + 95 + ], + "score": 1.0, + "content": "to pocketing any ball except the white ball, and to real-world discounts", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 397, + 83, + 438, + 94 + ], + "score": 0.9, + "content": "\\gamma = 0 . 9 8", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 438, + 82, + 456, + 95 + ], + "score": 1.0, + "content": "and", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 456, + 83, + 483, + 94 + ], + "score": 0.9, + "content": "\\gamma = 1", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 484, + 82, + 505, + 95 + ], + "score": 1.0, + "content": ". We", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 299, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 186, + 105 + ], + "score": 1.0, + "content": "select the condition", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 187, + 94, + 197, + 104 + ], + "score": 0.85, + "content": "s ^ { * }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 197, + 94, + 299, + 105 + ], + "score": 1.0, + "content": "that maximises this sum.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + } + ], + "index": 29, + "bbox_fs": [ + 105, + 531, + 506, + 588 + ] + }, + { + "type": "image", + "bbox": [ + 111, + 610, + 500, + 702 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 111, + 610, + 500, + 702 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 111, + 610, + 500, + 702 + ], + "spans": [ + { + "bbox": [ + 111, + 610, + 500, + 702 + ], + "score": 0.967, + "type": "image", + "image_path": "9e5eda1ba0817010e3a899cfcd39b4555fece7632765839f1302bb06efcfea60.jpg" + } + ] + } + ], + "index": 33, + "virtual_lines": [ + { + "bbox": [ + 111, + 610, + 500, + 640.6666666666666 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 111, + 640.6666666666666, + 500, + 671.3333333333333 + ], + "spans": [], + "index": 33 + }, + { + "bbox": [ + 111, + 671.3333333333333, + 500, + 701.9999999999999 + ], + "spans": [], + "index": 34 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 709, + 504, + 731 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "Figure 6: Thinking depth. Distributions of thinking depth on pool for different types of predictions", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 720, + 261, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 261, + 732 + ], + "score": 1.0, + "content": "and for different real-world discounts.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5 + } + ], + "index": 34.25 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 397, + 95 + ], + "score": 1.0, + "content": "to pocketing any ball except the white ball, and to real-world discounts", + "type": "text" + }, + { + "bbox": [ + 397, + 83, + 438, + 94 + ], + "score": 0.9, + "content": "\\gamma = 0 . 9 8", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 82, + 456, + 95 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 456, + 83, + 483, + 94 + ], + "score": 0.9, + "content": "\\gamma = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 82, + 505, + 95 + ], + "score": 1.0, + "content": ". We", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 299, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 186, + 105 + ], + "score": 1.0, + "content": "select the condition", + "type": "text" + }, + { + "bbox": [ + 187, + 94, + 197, + 104 + ], + "score": 0.85, + "content": "s ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 197, + 94, + 299, + 105 + ], + "score": 1.0, + "content": "that maximises this sum.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 107, + 107, + 505, + 184 + ], + "lines": [ + { + "bbox": [ + 106, + 107, + 506, + 120 + ], + "spans": [ + { + "bbox": [ + 106, + 107, + 291, + 120 + ], + "score": 1.0, + "content": "We then roll forward the pool simulator from", + "type": "text" + }, + { + "bbox": [ + 291, + 108, + 302, + 117 + ], + "score": 0.86, + "content": "s ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 302, + 107, + 506, + 120 + ], + "score": 1.0, + "content": "and log the number of pocketing events. Figure 2", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 118, + 506, + 132 + ], + "spans": [ + { + "bbox": [ + 105, + 118, + 328, + 132 + ], + "score": 1.0, + "content": "shows a sampled rollout, using the predictron to pick", + "type": "text" + }, + { + "bbox": [ + 328, + 119, + 338, + 128 + ], + "score": 0.86, + "content": "s ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 118, + 506, + 132 + ], + "score": 1.0, + "content": ". When providing the choice of 128 an-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 129, + 505, + 142 + ], + "spans": [ + { + "bbox": [ + 105, + 129, + 292, + 142 + ], + "score": 1.0, + "content": "gles and two velocities for initial conditions", + "type": "text" + }, + { + "bbox": [ + 293, + 129, + 338, + 141 + ], + "score": 0.9, + "content": "\\left. \\vert I \\right. = 2 5 6 )", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 129, + 505, + 142 + ], + "score": 1.0, + "content": ", this procedure resulted in pocketing 27", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 140, + 505, + 153 + ], + "spans": [ + { + "bbox": [ + 106, + 140, + 505, + 153 + ], + "score": 1.0, + "content": "coloured balls in 50 episodes. Using the same procedure with an equally deep convolutional net-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 151, + 505, + 164 + ], + "spans": [ + { + "bbox": [ + 106, + 151, + 505, + 164 + ], + "score": 1.0, + "content": "work only resulted in 10 pocketing events. These results suggest that the lower loss of the learned", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 107, + 162, + 506, + 174 + ], + "spans": [ + { + "bbox": [ + 107, + 162, + 140, + 174 + ], + "score": 0.92, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 163, + 506, + 174 + ], + "score": 1.0, + "content": "-predictron translated into meaningful improvements when informing decisions. A video of", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 173, + 503, + 185 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 503, + 185 + ], + "score": 1.0, + "content": "the rollouts selected by the predictron is available here: https://youtu.be/BeaLdaN2C3Q.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5 + }, + { + "type": "title", + "bbox": [ + 107, + 197, + 209, + 210 + ], + "lines": [ + { + "bbox": [ + 105, + 196, + 210, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 196, + 210, + 212 + ], + "score": 1.0, + "content": "6 RELATED WORK", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 107, + 219, + 505, + 285 + ], + "lines": [ + { + "bbox": [ + 105, + 218, + 505, + 231 + ], + "spans": [ + { + "bbox": [ + 105, + 218, + 505, + 231 + ], + "score": 1.0, + "content": "Lee et al. (2015) introduced a neural network architecture where classifications branch off interme-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 229, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 105, + 229, + 361, + 243 + ], + "score": 1.0, + "content": "diate hidden layers. An important difference with respect to the", + "type": "text" + }, + { + "bbox": [ + 361, + 231, + 368, + 240 + ], + "score": 0.8, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 368, + 229, + 505, + 243 + ], + "score": 1.0, + "content": "-predictron, is that the weights are", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 241, + 505, + 253 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 361, + 253 + ], + "score": 1.0, + "content": "hand-tuned as hyper-parameters, whereas in the predictron the", + "type": "text" + }, + { + "bbox": [ + 361, + 241, + 369, + 251 + ], + "score": 0.71, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 241, + 505, + 253 + ], + "score": 1.0, + "content": "weights are learnt and, more im-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 104, + 252, + 506, + 265 + ], + "spans": [ + { + "bbox": [ + 104, + 252, + 506, + 265 + ], + "score": 1.0, + "content": "portantly, conditional on the input. Another difference is that the loss on the auxiliary classifications", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "score": 1.0, + "content": "is used to speed up learning, but the classifications themselves are not combined into an aggregate", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 274, + 372, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 274, + 372, + 286 + ], + "score": 1.0, + "content": "prediction; the output of the model itself is the deepest prediction.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 107, + 288, + 505, + 331 + ], + "lines": [ + { + "bbox": [ + 105, + 288, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 505, + 299 + ], + "score": 1.0, + "content": "Graves (2016) introduced an architecture with adaptive computation time (ACT), with a discrete", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 298, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 505, + 312 + ], + "score": 1.0, + "content": "(but differentiable) decision on when to halt, and aggregating over the outputs at each pondering", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 310, + 505, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 310, + 213, + 322 + ], + "score": 1.0, + "content": "step. This is related to our", + "type": "text" + }, + { + "bbox": [ + 213, + 310, + 221, + 320 + ], + "score": 0.56, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 221, + 310, + 505, + 322 + ], + "score": 1.0, + "content": "weights, but obtains depth in a different way; one notable difference is", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 320, + 453, + 333 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 138, + 333 + ], + "score": 1.0, + "content": "that the", + "type": "text" + }, + { + "bbox": [ + 138, + 321, + 146, + 330 + ], + "score": 0.78, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 320, + 453, + 333 + ], + "score": 1.0, + "content": "-predictron can choose different pondering depths for each of its predictions.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 107, + 334, + 504, + 389 + ], + "lines": [ + { + "bbox": [ + 106, + 333, + 506, + 348 + ], + "spans": [ + { + "bbox": [ + 106, + 333, + 506, + 348 + ], + "score": 1.0, + "content": "Value iteration networks (VINs) (Tamar et al., 2016) also learn value functions end-to-end using an", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 345, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 106, + 345, + 246, + 357 + ], + "score": 1.0, + "content": "internal model, similar to the (non-", + "type": "text" + }, + { + "bbox": [ + 247, + 346, + 253, + 355 + ], + "score": 0.58, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 345, + 505, + 357 + ], + "score": 1.0, + "content": ") predictron. However, VINs plan via convolutional operations", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 357, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 106, + 357, + 505, + 368 + ], + "score": 1.0, + "content": "over the full input state space; whereas the predictron plans via imagined trajectories through an", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 368, + 505, + 380 + ], + "spans": [ + { + "bbox": [ + 106, + 368, + 505, + 380 + ], + "score": 1.0, + "content": "abstract state space. This may allow the predictron architecture to scale much more effectively in", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 377, + 428, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 377, + 428, + 392 + ], + "score": 1.0, + "content": "domains that do not have a natural two-dimensional encoding of the state space.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 392, + 504, + 447 + ], + "lines": [ + { + "bbox": [ + 106, + 392, + 506, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 506, + 404 + ], + "score": 1.0, + "content": "The notion of learning about many predictions of the future relates to work on predictive state", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 403, + 506, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 506, + 415 + ], + "score": 1.0, + "content": "representations (PSRs; Littman et al., 2001), general value functions (GVFs; Sutton et al., 2011),", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 413, + 505, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 505, + 426 + ], + "score": 1.0, + "content": "and nexting (Modayil et al., 2012). Such predictions have been shown to be useful as representa-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 425, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 106, + 425, + 505, + 437 + ], + "score": 1.0, + "content": "tions (Schaul and Ring, 2013) and for transfer (Schaul et al., 2015). So far, however, none of these", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 436, + 310, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 436, + 310, + 448 + ], + "score": 1.0, + "content": "have been considered for learning abstract models.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 450, + 504, + 493 + ], + "lines": [ + { + "bbox": [ + 106, + 450, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 450, + 505, + 461 + ], + "score": 1.0, + "content": "Schmidhuber (2015) discusses learning abstract models, but maintains separate losses for the model", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 460, + 506, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 506, + 474 + ], + "score": 1.0, + "content": "and a controller, and suggests training the model unsupervised to compactly encode the entire history", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 471, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 506, + 484 + ], + "score": 1.0, + "content": "of observations, through predictive coding. The predictron’s abstract model is instead trained end-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 484, + 237, + 494 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 237, + 494 + ], + "score": 1.0, + "content": "to-end to obtain accurate values.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31.5 + }, + { + "type": "title", + "bbox": [ + 108, + 506, + 195, + 519 + ], + "lines": [ + { + "bbox": [ + 104, + 504, + 198, + 523 + ], + "spans": [ + { + "bbox": [ + 104, + 504, + 198, + 523 + ], + "score": 1.0, + "content": "7 CONCLUSION", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 528, + 505, + 594 + ], + "lines": [ + { + "bbox": [ + 106, + 529, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 106, + 529, + 505, + 540 + ], + "score": 1.0, + "content": "The predictron is a single differentiable architecture that rolls forward an internal model to estimate", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 539, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 505, + 551 + ], + "score": 1.0, + "content": "external values. This internal model may be given both the structure and the semantics of tradi-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 550, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 505, + 563 + ], + "score": 1.0, + "content": "tional reinforcement learning models. But unlike most approaches to model-based reinforcement", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 561, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 505, + 574 + ], + "score": 1.0, + "content": "learning, the model is fully abstract: it need not correspond to the real environment in any human", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 572, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 506, + 585 + ], + "score": 1.0, + "content": "understandable fashion, so long as its rolled-forward “plans” accurately predict outcomes in the true", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 585, + 161, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 585, + 161, + 595 + ], + "score": 1.0, + "content": "environment.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 37.5 + }, + { + "type": "text", + "bbox": [ + 107, + 597, + 505, + 685 + ], + "lines": [ + { + "bbox": [ + 105, + 597, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 505, + 609 + ], + "score": 1.0, + "content": "The predictron may be viewed as a novel network architecture that incorporates several separable", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 608, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 608, + 505, + 621 + ], + "score": 1.0, + "content": "ideas. First, the predictron outputs a value by accumulating rewards over a series of internal planning", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 619, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 505, + 632 + ], + "score": 1.0, + "content": "steps. Second, each forward pass of the predictron outputs values at multiple planning depths. Third,", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 630, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 505, + 642 + ], + "score": 1.0, + "content": "these values may be combined together, also within a single forward pass, to output an overall", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 640, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 505, + 654 + ], + "score": 1.0, + "content": "ensemble value. Finally, the different values output by the predictron may be encouraged to be", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 651, + 506, + 665 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 506, + 665 + ], + "score": 1.0, + "content": "self-consistent with each other, to provide an additional signal during learning. Our experiments", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 663, + 506, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 506, + 675 + ], + "score": 1.0, + "content": "demonstrate that these differences result in more accurate predictions of value, in reinforcement", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 674, + 388, + 686 + ], + "spans": [ + { + "bbox": [ + 105, + 674, + 388, + 686 + ], + "score": 1.0, + "content": "learning environments, than more conventional network architectures.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 44.5 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "We have focused on value prediction tasks in uncontrolled environments. However, these ideas may", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "transfer to the control setting, for example by using the predictron as a Q-network (Mnih et al.,", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "2015). Even more intriguing is the possibility of learning an internal MDP with abstract internal", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 721, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 505, + 732 + ], + "score": 1.0, + "content": "actions, rather than the MRP considered in this paper. We aim to explore these ideas in future work.", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 50.5 + } + ], + "page_idx": 7, + "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, + 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": [ + 106, + 82, + 504, + 105 + ], + "lines": [], + "index": 0.5, + "bbox_fs": [ + 105, + 82, + 505, + 105 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 107, + 505, + 184 + ], + "lines": [ + { + "bbox": [ + 106, + 107, + 506, + 120 + ], + "spans": [ + { + "bbox": [ + 106, + 107, + 291, + 120 + ], + "score": 1.0, + "content": "We then roll forward the pool simulator from", + "type": "text" + }, + { + "bbox": [ + 291, + 108, + 302, + 117 + ], + "score": 0.86, + "content": "s ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 302, + 107, + 506, + 120 + ], + "score": 1.0, + "content": "and log the number of pocketing events. Figure 2", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 118, + 506, + 132 + ], + "spans": [ + { + "bbox": [ + 105, + 118, + 328, + 132 + ], + "score": 1.0, + "content": "shows a sampled rollout, using the predictron to pick", + "type": "text" + }, + { + "bbox": [ + 328, + 119, + 338, + 128 + ], + "score": 0.86, + "content": "s ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 118, + 506, + 132 + ], + "score": 1.0, + "content": ". When providing the choice of 128 an-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 129, + 505, + 142 + ], + "spans": [ + { + "bbox": [ + 105, + 129, + 292, + 142 + ], + "score": 1.0, + "content": "gles and two velocities for initial conditions", + "type": "text" + }, + { + "bbox": [ + 293, + 129, + 338, + 141 + ], + "score": 0.9, + "content": "\\left. \\vert I \\right. = 2 5 6 )", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 129, + 505, + 142 + ], + "score": 1.0, + "content": ", this procedure resulted in pocketing 27", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 140, + 505, + 153 + ], + "spans": [ + { + "bbox": [ + 106, + 140, + 505, + 153 + ], + "score": 1.0, + "content": "coloured balls in 50 episodes. Using the same procedure with an equally deep convolutional net-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 151, + 505, + 164 + ], + "spans": [ + { + "bbox": [ + 106, + 151, + 505, + 164 + ], + "score": 1.0, + "content": "work only resulted in 10 pocketing events. These results suggest that the lower loss of the learned", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 107, + 162, + 506, + 174 + ], + "spans": [ + { + "bbox": [ + 107, + 162, + 140, + 174 + ], + "score": 0.92, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 163, + 506, + 174 + ], + "score": 1.0, + "content": "-predictron translated into meaningful improvements when informing decisions. A video of", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 173, + 503, + 185 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 503, + 185 + ], + "score": 1.0, + "content": "the rollouts selected by the predictron is available here: https://youtu.be/BeaLdaN2C3Q.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5, + "bbox_fs": [ + 105, + 107, + 506, + 185 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 197, + 209, + 210 + ], + "lines": [ + { + "bbox": [ + 105, + 196, + 210, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 196, + 210, + 212 + ], + "score": 1.0, + "content": "6 RELATED WORK", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 107, + 219, + 505, + 285 + ], + "lines": [ + { + "bbox": [ + 105, + 218, + 505, + 231 + ], + "spans": [ + { + "bbox": [ + 105, + 218, + 505, + 231 + ], + "score": 1.0, + "content": "Lee et al. (2015) introduced a neural network architecture where classifications branch off interme-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 229, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 105, + 229, + 361, + 243 + ], + "score": 1.0, + "content": "diate hidden layers. An important difference with respect to the", + "type": "text" + }, + { + "bbox": [ + 361, + 231, + 368, + 240 + ], + "score": 0.8, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 368, + 229, + 505, + 243 + ], + "score": 1.0, + "content": "-predictron, is that the weights are", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 241, + 505, + 253 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 361, + 253 + ], + "score": 1.0, + "content": "hand-tuned as hyper-parameters, whereas in the predictron the", + "type": "text" + }, + { + "bbox": [ + 361, + 241, + 369, + 251 + ], + "score": 0.71, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 241, + 505, + 253 + ], + "score": 1.0, + "content": "weights are learnt and, more im-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 104, + 252, + 506, + 265 + ], + "spans": [ + { + "bbox": [ + 104, + 252, + 506, + 265 + ], + "score": 1.0, + "content": "portantly, conditional on the input. Another difference is that the loss on the auxiliary classifications", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "score": 1.0, + "content": "is used to speed up learning, but the classifications themselves are not combined into an aggregate", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 274, + 372, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 274, + 372, + 286 + ], + "score": 1.0, + "content": "prediction; the output of the model itself is the deepest prediction.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 12.5, + "bbox_fs": [ + 104, + 218, + 506, + 286 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 288, + 505, + 331 + ], + "lines": [ + { + "bbox": [ + 105, + 288, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 505, + 299 + ], + "score": 1.0, + "content": "Graves (2016) introduced an architecture with adaptive computation time (ACT), with a discrete", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 298, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 505, + 312 + ], + "score": 1.0, + "content": "(but differentiable) decision on when to halt, and aggregating over the outputs at each pondering", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 310, + 505, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 310, + 213, + 322 + ], + "score": 1.0, + "content": "step. This is related to our", + "type": "text" + }, + { + "bbox": [ + 213, + 310, + 221, + 320 + ], + "score": 0.56, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 221, + 310, + 505, + 322 + ], + "score": 1.0, + "content": "weights, but obtains depth in a different way; one notable difference is", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 320, + 453, + 333 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 138, + 333 + ], + "score": 1.0, + "content": "that the", + "type": "text" + }, + { + "bbox": [ + 138, + 321, + 146, + 330 + ], + "score": 0.78, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 320, + 453, + 333 + ], + "score": 1.0, + "content": "-predictron can choose different pondering depths for each of its predictions.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 17.5, + "bbox_fs": [ + 105, + 288, + 505, + 333 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 334, + 504, + 389 + ], + "lines": [ + { + "bbox": [ + 106, + 333, + 506, + 348 + ], + "spans": [ + { + "bbox": [ + 106, + 333, + 506, + 348 + ], + "score": 1.0, + "content": "Value iteration networks (VINs) (Tamar et al., 2016) also learn value functions end-to-end using an", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 345, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 106, + 345, + 246, + 357 + ], + "score": 1.0, + "content": "internal model, similar to the (non-", + "type": "text" + }, + { + "bbox": [ + 247, + 346, + 253, + 355 + ], + "score": 0.58, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 345, + 505, + 357 + ], + "score": 1.0, + "content": ") predictron. However, VINs plan via convolutional operations", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 357, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 106, + 357, + 505, + 368 + ], + "score": 1.0, + "content": "over the full input state space; whereas the predictron plans via imagined trajectories through an", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 368, + 505, + 380 + ], + "spans": [ + { + "bbox": [ + 106, + 368, + 505, + 380 + ], + "score": 1.0, + "content": "abstract state space. This may allow the predictron architecture to scale much more effectively in", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 377, + 428, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 377, + 428, + 392 + ], + "score": 1.0, + "content": "domains that do not have a natural two-dimensional encoding of the state space.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22, + "bbox_fs": [ + 105, + 333, + 506, + 392 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 392, + 504, + 447 + ], + "lines": [ + { + "bbox": [ + 106, + 392, + 506, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 506, + 404 + ], + "score": 1.0, + "content": "The notion of learning about many predictions of the future relates to work on predictive state", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 403, + 506, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 506, + 415 + ], + "score": 1.0, + "content": "representations (PSRs; Littman et al., 2001), general value functions (GVFs; Sutton et al., 2011),", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 413, + 505, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 505, + 426 + ], + "score": 1.0, + "content": "and nexting (Modayil et al., 2012). Such predictions have been shown to be useful as representa-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 425, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 106, + 425, + 505, + 437 + ], + "score": 1.0, + "content": "tions (Schaul and Ring, 2013) and for transfer (Schaul et al., 2015). So far, however, none of these", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 436, + 310, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 436, + 310, + 448 + ], + "score": 1.0, + "content": "have been considered for learning abstract models.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 392, + 506, + 448 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 450, + 504, + 493 + ], + "lines": [ + { + "bbox": [ + 106, + 450, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 450, + 505, + 461 + ], + "score": 1.0, + "content": "Schmidhuber (2015) discusses learning abstract models, but maintains separate losses for the model", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 460, + 506, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 506, + 474 + ], + "score": 1.0, + "content": "and a controller, and suggests training the model unsupervised to compactly encode the entire history", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 471, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 506, + 484 + ], + "score": 1.0, + "content": "of observations, through predictive coding. The predictron’s abstract model is instead trained end-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 484, + 237, + 494 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 237, + 494 + ], + "score": 1.0, + "content": "to-end to obtain accurate values.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31.5, + "bbox_fs": [ + 105, + 450, + 506, + 494 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 506, + 195, + 519 + ], + "lines": [ + { + "bbox": [ + 104, + 504, + 198, + 523 + ], + "spans": [ + { + "bbox": [ + 104, + 504, + 198, + 523 + ], + "score": 1.0, + "content": "7 CONCLUSION", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 528, + 505, + 594 + ], + "lines": [ + { + "bbox": [ + 106, + 529, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 106, + 529, + 505, + 540 + ], + "score": 1.0, + "content": "The predictron is a single differentiable architecture that rolls forward an internal model to estimate", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 539, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 505, + 551 + ], + "score": 1.0, + "content": "external values. This internal model may be given both the structure and the semantics of tradi-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 550, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 505, + 563 + ], + "score": 1.0, + "content": "tional reinforcement learning models. But unlike most approaches to model-based reinforcement", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 561, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 505, + 574 + ], + "score": 1.0, + "content": "learning, the model is fully abstract: it need not correspond to the real environment in any human", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 572, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 506, + 585 + ], + "score": 1.0, + "content": "understandable fashion, so long as its rolled-forward “plans” accurately predict outcomes in the true", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 585, + 161, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 585, + 161, + 595 + ], + "score": 1.0, + "content": "environment.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 37.5, + "bbox_fs": [ + 105, + 529, + 506, + 595 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 597, + 505, + 685 + ], + "lines": [ + { + "bbox": [ + 105, + 597, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 505, + 609 + ], + "score": 1.0, + "content": "The predictron may be viewed as a novel network architecture that incorporates several separable", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 608, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 608, + 505, + 621 + ], + "score": 1.0, + "content": "ideas. First, the predictron outputs a value by accumulating rewards over a series of internal planning", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 619, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 505, + 632 + ], + "score": 1.0, + "content": "steps. Second, each forward pass of the predictron outputs values at multiple planning depths. Third,", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 630, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 505, + 642 + ], + "score": 1.0, + "content": "these values may be combined together, also within a single forward pass, to output an overall", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 640, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 505, + 654 + ], + "score": 1.0, + "content": "ensemble value. Finally, the different values output by the predictron may be encouraged to be", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 651, + 506, + 665 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 506, + 665 + ], + "score": 1.0, + "content": "self-consistent with each other, to provide an additional signal during learning. Our experiments", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 663, + 506, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 506, + 675 + ], + "score": 1.0, + "content": "demonstrate that these differences result in more accurate predictions of value, in reinforcement", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 674, + 388, + 686 + ], + "spans": [ + { + "bbox": [ + 105, + 674, + 388, + 686 + ], + "score": 1.0, + "content": "learning environments, than more conventional network architectures.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 44.5, + "bbox_fs": [ + 105, + 597, + 506, + 686 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "We have focused on value prediction tasks in uncontrolled environments. However, these ideas may", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "transfer to the control setting, for example by using the predictron as a Q-network (Mnih et al.,", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "2015). Even more intriguing is the possibility of learning an internal MDP with abstract internal", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 721, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 505, + 732 + ], + "score": 1.0, + "content": "actions, rather than the MRP considered in this paper. We aim to explore these ideas in future work.", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 50.5, + "bbox_fs": [ + 105, + 687, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 82, + 176, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 176, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 176, + 95 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 100, + 392, + 113 + ], + "lines": [ + { + "bbox": [ + 106, + 100, + 392, + 114 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 392, + 114 + ], + "score": 1.0, + "content": "R. Bellman. Dynamic programming. Princeton University Press, 1957.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 106, + 119, + 502, + 131 + ], + "lines": [ + { + "bbox": [ + 106, + 119, + 502, + 133 + ], + "spans": [ + { + "bbox": [ + 106, + 119, + 502, + 133 + ], + "score": 1.0, + "content": "S. Chiappa, S. Racaniere, D. Wierstra, and S. Mohamed. Recurrent environment simulators. 2016.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 106, + 138, + 503, + 162 + ], + "lines": [ + { + "bbox": [ + 105, + 137, + 505, + 152 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 505, + 152 + ], + "score": 1.0, + "content": "X. Glorot, A. Bordes, and Y. Bengio. Deep sparse rectifier neural networks. In Aistats, volume 15,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 150, + 183, + 162 + ], + "spans": [ + { + "bbox": [ + 115, + 150, + 183, + 162 + ], + "score": 1.0, + "content": "page 275, 2011.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 106, + 169, + 504, + 192 + ], + "lines": [ + { + "bbox": [ + 106, + 169, + 505, + 182 + ], + "spans": [ + { + "bbox": [ + 106, + 169, + 505, + 182 + ], + "score": 1.0, + "content": "A. Graves. Adaptive computation time for recurrent neural networks. CoRR, abs/1603.08983, 2016.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 117, + 181, + 329, + 192 + ], + "spans": [ + { + "bbox": [ + 117, + 181, + 329, + 192 + ], + "score": 1.0, + "content": "URL http://arxiv.org/abs/1603.08983.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 106, + 199, + 505, + 222 + ], + "lines": [ + { + "bbox": [ + 105, + 199, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 505, + 213 + ], + "score": 1.0, + "content": "K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. arXiv preprint", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 210, + 219, + 221 + ], + "spans": [ + { + "bbox": [ + 115, + 210, + 219, + 221 + ], + "score": 1.0, + "content": "arXiv:1512.03385, 2015.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 105, + 230, + 505, + 253 + ], + "lines": [ + { + "bbox": [ + 105, + 228, + 505, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 228, + 505, + 244 + ], + "score": 1.0, + "content": "S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 116, + 241, + 374, + 253 + ], + "spans": [ + { + "bbox": [ + 116, + 241, + 374, + 253 + ], + "score": 1.0, + "content": "internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 106, + 259, + 504, + 283 + ], + "lines": [ + { + "bbox": [ + 105, + 259, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 505, + 273 + ], + "score": 1.0, + "content": "D. P. Kingma and J. Ba. A method for stochastic optimization. In International Conference on", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 115, + 271, + 245, + 284 + ], + "spans": [ + { + "bbox": [ + 115, + 271, + 245, + 284 + ], + "score": 1.0, + "content": "Learning Representation, 2015.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 105, + 290, + 504, + 314 + ], + "lines": [ + { + "bbox": [ + 105, + 290, + 505, + 304 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 505, + 304 + ], + "score": 1.0, + "content": "Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 115, + 302, + 375, + 313 + ], + "spans": [ + { + "bbox": [ + 115, + 302, + 375, + 313 + ], + "score": 1.0, + "content": "recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 106, + 320, + 504, + 344 + ], + "lines": [ + { + "bbox": [ + 105, + 319, + 506, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 319, + 506, + 335 + ], + "score": 1.0, + "content": "C.-Y. Lee, S. Xie, P. Gallagher, Z. Zhang, and Z. Tu. Deeply-supervised nets. In AISTATS, volume 2,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 332, + 173, + 344 + ], + "spans": [ + { + "bbox": [ + 115, + 332, + 173, + 344 + ], + "score": 1.0, + "content": "page 6, 2015.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 104, + 351, + 504, + 375 + ], + "lines": [ + { + "bbox": [ + 106, + 351, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 505, + 364 + ], + "score": 1.0, + "content": "T. Lillicrap, J. Hunt, A. Pritzel, N. Heess, T. Erez, Y. Tassa, D. Silver, and D. Wierstra. Continuous", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 363, + 348, + 375 + ], + "spans": [ + { + "bbox": [ + 115, + 363, + 348, + 375 + ], + "score": 1.0, + "content": "control with deep reinforcement learning. In ICLR, 2016.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 105, + 381, + 503, + 405 + ], + "lines": [ + { + "bbox": [ + 105, + 380, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 505, + 394 + ], + "score": 1.0, + "content": "M. L. Littman, R. S. Sutton, and S. P. Singh. Predictive representations of state. In NIPS, volume 14,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 393, + 217, + 405 + ], + "spans": [ + { + "bbox": [ + 115, + 393, + 217, + 405 + ], + "score": 1.0, + "content": "pages 1555–1561, 2001.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 107, + 411, + 505, + 457 + ], + "lines": [ + { + "bbox": [ + 105, + 412, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 505, + 425 + ], + "score": 1.0, + "content": "V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Ried-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 421, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 115, + 421, + 505, + 437 + ], + "score": 1.0, + "content": "miller, A. K. Fidjeland, G. Ostrovski, S. Petersen, C. Beattie, A. Sadik, I. Antonoglou, H. King,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 115, + 434, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 115, + 434, + 505, + 447 + ], + "score": 1.0, + "content": "D. Kumaran, D. Wierstra, S. Legg, and D. Hassabis. Human-level control through deep reinforce-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 445, + 319, + 457 + ], + "spans": [ + { + "bbox": [ + 115, + 445, + 319, + 457 + ], + "score": 1.0, + "content": "ment learning. Nature, 518(7540):529–533, 2015.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 106, + 464, + 504, + 498 + ], + "lines": [ + { + "bbox": [ + 106, + 463, + 504, + 477 + ], + "spans": [ + { + "bbox": [ + 106, + 463, + 504, + 477 + ], + "score": 1.0, + "content": "V. Mnih, A. P. Badia, M. Mirza, A. Graves, T. Lillicrap, T. Harley, D. Silver, and K. Kavukcuoglu.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 117, + 476, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 117, + 476, + 505, + 487 + ], + "score": 1.0, + "content": "Asynchronous methods for deep reinforcement learning. In International Conference on Machine", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 486, + 183, + 499 + ], + "spans": [ + { + "bbox": [ + 115, + 486, + 183, + 499 + ], + "score": 1.0, + "content": "Learning, 2016.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 505, + 505, + 529 + ], + "lines": [ + { + "bbox": [ + 105, + 505, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 505, + 518 + ], + "score": 1.0, + "content": "J. Modayil, A. White, and R. S. Sutton. Multi-timescale nexting in a reinforcement learning robot.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 516, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 115, + 516, + 505, + 529 + ], + "score": 1.0, + "content": "In International Conference on Simulation of Adaptive Behavior, pages 299–309. Springer, 2012.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 105, + 535, + 504, + 569 + ], + "lines": [ + { + "bbox": [ + 104, + 534, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 104, + 534, + 505, + 549 + ], + "score": 1.0, + "content": "J. Oh, X. Guo, H. Lee, R. L. Lewis, and S. Singh. Action-conditional video prediction using deep", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 114, + 546, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 114, + 546, + 505, + 559 + ], + "score": 1.0, + "content": "networks in atari games. In Advances in Neural Information Processing Systems, pages 2863–", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 556, + 167, + 570 + ], + "spans": [ + { + "bbox": [ + 115, + 556, + 167, + 570 + ], + "score": 1.0, + "content": "2871, 2015.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 105, + 576, + 504, + 601 + ], + "lines": [ + { + "bbox": [ + 105, + 577, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 505, + 590 + ], + "score": 1.0, + "content": "T. Schaul and M. B. Ring. Better Generalization with Forecasts. In Proceedings of the International", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 116, + 588, + 411, + 601 + ], + "spans": [ + { + "bbox": [ + 116, + 588, + 411, + 601 + ], + "score": 1.0, + "content": "Joint Conference on Artificial Intelligence (IJCAI), Beijing, China, 2013.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33.5 + }, + { + "type": "text", + "bbox": [ + 106, + 607, + 504, + 631 + ], + "lines": [ + { + "bbox": [ + 106, + 606, + 505, + 620 + ], + "spans": [ + { + "bbox": [ + 106, + 606, + 505, + 620 + ], + "score": 1.0, + "content": "T. Schaul, D. Horgan, K. Gregor, and D. Silver. Universal Value Function Approximators. In", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 618, + 369, + 631 + ], + "spans": [ + { + "bbox": [ + 116, + 618, + 369, + 631 + ], + "score": 1.0, + "content": "International Conference on Machine Learning (ICML), 2015.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 107, + 637, + 504, + 672 + ], + "lines": [ + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "J. Schmidhuber. On learning to think: Algorithmic information theory for novel combina-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 116, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 116, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "tions of reinforcement learning controllers and recurrent neural world models. arXiv preprint", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 659, + 219, + 672 + ], + "spans": [ + { + "bbox": [ + 116, + 659, + 219, + 672 + ], + "score": 1.0, + "content": "arXiv:1511.09249, 2015.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 106, + 679, + 502, + 702 + ], + "lines": [ + { + "bbox": [ + 105, + 678, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 505, + 693 + ], + "score": 1.0, + "content": "R. S. Sutton. Learning to predict by the methods of temporal differences. Machine Learning, 3:", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 116, + 690, + 166, + 702 + ], + "spans": [ + { + "bbox": [ + 116, + 690, + 166, + 702 + ], + "score": 1.0, + "content": "9–44, 1988.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 502, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 504, + 722 + ], + "score": 1.0, + "content": "R. S. Sutton. TD models: Modeling the world at a mixture of time scales. In Proceedings of the", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 720, + 433, + 733 + ], + "spans": [ + { + "bbox": [ + 115, + 720, + 433, + 733 + ], + "score": 1.0, + "content": "Twelfth International Conference on Machine Learning, pages 531–539, 1995.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 26, + 308, + 38 + ], + "lines": [ + { + "bbox": [ + 107, + 25, + 308, + 39 + ], + "spans": [ + { + "bbox": [ + 107, + 25, + 308, + 39 + ], + "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": "title", + "bbox": [ + 107, + 82, + 176, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 176, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 176, + 95 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 100, + 392, + 113 + ], + "lines": [ + { + "bbox": [ + 106, + 100, + 392, + 114 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 392, + 114 + ], + "score": 1.0, + "content": "R. Bellman. Dynamic programming. Princeton University Press, 1957.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1, + "bbox_fs": [ + 106, + 100, + 392, + 114 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 119, + 502, + 131 + ], + "lines": [ + { + "bbox": [ + 106, + 119, + 502, + 133 + ], + "spans": [ + { + "bbox": [ + 106, + 119, + 502, + 133 + ], + "score": 1.0, + "content": "S. Chiappa, S. Racaniere, D. Wierstra, and S. Mohamed. Recurrent environment simulators. 2016.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2, + "bbox_fs": [ + 106, + 119, + 502, + 133 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 138, + 503, + 162 + ], + "lines": [ + { + "bbox": [ + 105, + 137, + 505, + 152 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 505, + 152 + ], + "score": 1.0, + "content": "X. Glorot, A. Bordes, and Y. Bengio. Deep sparse rectifier neural networks. In Aistats, volume 15,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 150, + 183, + 162 + ], + "spans": [ + { + "bbox": [ + 115, + 150, + 183, + 162 + ], + "score": 1.0, + "content": "page 275, 2011.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 137, + 505, + 162 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 169, + 504, + 192 + ], + "lines": [ + { + "bbox": [ + 106, + 169, + 505, + 182 + ], + "spans": [ + { + "bbox": [ + 106, + 169, + 505, + 182 + ], + "score": 1.0, + "content": "A. Graves. Adaptive computation time for recurrent neural networks. CoRR, abs/1603.08983, 2016.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 117, + 181, + 329, + 192 + ], + "spans": [ + { + "bbox": [ + 117, + 181, + 329, + 192 + ], + "score": 1.0, + "content": "URL http://arxiv.org/abs/1603.08983.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5, + "bbox_fs": [ + 106, + 169, + 505, + 192 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 199, + 505, + 222 + ], + "lines": [ + { + "bbox": [ + 105, + 199, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 505, + 213 + ], + "score": 1.0, + "content": "K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. arXiv preprint", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 210, + 219, + 221 + ], + "spans": [ + { + "bbox": [ + 115, + 210, + 219, + 221 + ], + "score": 1.0, + "content": "arXiv:1512.03385, 2015.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5, + "bbox_fs": [ + 105, + 199, + 505, + 221 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 230, + 505, + 253 + ], + "lines": [ + { + "bbox": [ + 105, + 228, + 505, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 228, + 505, + 244 + ], + "score": 1.0, + "content": "S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 116, + 241, + 374, + 253 + ], + "spans": [ + { + "bbox": [ + 116, + 241, + 374, + 253 + ], + "score": 1.0, + "content": "internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 228, + 505, + 253 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 259, + 504, + 283 + ], + "lines": [ + { + "bbox": [ + 105, + 259, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 505, + 273 + ], + "score": 1.0, + "content": "D. P. Kingma and J. Ba. A method for stochastic optimization. In International Conference on", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 115, + 271, + 245, + 284 + ], + "spans": [ + { + "bbox": [ + 115, + 271, + 245, + 284 + ], + "score": 1.0, + "content": "Learning Representation, 2015.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 259, + 505, + 284 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 290, + 504, + 314 + ], + "lines": [ + { + "bbox": [ + 105, + 290, + 505, + 304 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 505, + 304 + ], + "score": 1.0, + "content": "Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 115, + 302, + 375, + 313 + ], + "spans": [ + { + "bbox": [ + 115, + 302, + 375, + 313 + ], + "score": 1.0, + "content": "recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5, + "bbox_fs": [ + 105, + 290, + 505, + 313 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 320, + 504, + 344 + ], + "lines": [ + { + "bbox": [ + 105, + 319, + 506, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 319, + 506, + 335 + ], + "score": 1.0, + "content": "C.-Y. Lee, S. Xie, P. Gallagher, Z. Zhang, and Z. Tu. Deeply-supervised nets. In AISTATS, volume 2,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 332, + 173, + 344 + ], + "spans": [ + { + "bbox": [ + 115, + 332, + 173, + 344 + ], + "score": 1.0, + "content": "page 6, 2015.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 319, + 506, + 344 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 351, + 504, + 375 + ], + "lines": [ + { + "bbox": [ + 106, + 351, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 505, + 364 + ], + "score": 1.0, + "content": "T. Lillicrap, J. Hunt, A. Pritzel, N. Heess, T. Erez, Y. Tassa, D. Silver, and D. Wierstra. Continuous", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 363, + 348, + 375 + ], + "spans": [ + { + "bbox": [ + 115, + 363, + 348, + 375 + ], + "score": 1.0, + "content": "control with deep reinforcement learning. In ICLR, 2016.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5, + "bbox_fs": [ + 106, + 351, + 505, + 375 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 381, + 503, + 405 + ], + "lines": [ + { + "bbox": [ + 105, + 380, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 505, + 394 + ], + "score": 1.0, + "content": "M. L. Littman, R. S. Sutton, and S. P. Singh. Predictive representations of state. In NIPS, volume 14,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 393, + 217, + 405 + ], + "spans": [ + { + "bbox": [ + 115, + 393, + 217, + 405 + ], + "score": 1.0, + "content": "pages 1555–1561, 2001.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 380, + 505, + 405 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 411, + 505, + 457 + ], + "lines": [ + { + "bbox": [ + 105, + 412, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 505, + 425 + ], + "score": 1.0, + "content": "V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Ried-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 421, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 115, + 421, + 505, + 437 + ], + "score": 1.0, + "content": "miller, A. K. Fidjeland, G. Ostrovski, S. Petersen, C. Beattie, A. Sadik, I. Antonoglou, H. King,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 115, + 434, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 115, + 434, + 505, + 447 + ], + "score": 1.0, + "content": "D. Kumaran, D. Wierstra, S. Legg, and D. Hassabis. Human-level control through deep reinforce-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 445, + 319, + 457 + ], + "spans": [ + { + "bbox": [ + 115, + 445, + 319, + 457 + ], + "score": 1.0, + "content": "ment learning. Nature, 518(7540):529–533, 2015.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 412, + 505, + 457 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 464, + 504, + 498 + ], + "lines": [ + { + "bbox": [ + 106, + 463, + 504, + 477 + ], + "spans": [ + { + "bbox": [ + 106, + 463, + 504, + 477 + ], + "score": 1.0, + "content": "V. Mnih, A. P. Badia, M. Mirza, A. Graves, T. Lillicrap, T. Harley, D. Silver, and K. Kavukcuoglu.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 117, + 476, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 117, + 476, + 505, + 487 + ], + "score": 1.0, + "content": "Asynchronous methods for deep reinforcement learning. In International Conference on Machine", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 486, + 183, + 499 + ], + "spans": [ + { + "bbox": [ + 115, + 486, + 183, + 499 + ], + "score": 1.0, + "content": "Learning, 2016.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26, + "bbox_fs": [ + 106, + 463, + 505, + 499 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 505, + 505, + 529 + ], + "lines": [ + { + "bbox": [ + 105, + 505, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 505, + 518 + ], + "score": 1.0, + "content": "J. Modayil, A. White, and R. S. Sutton. Multi-timescale nexting in a reinforcement learning robot.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 516, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 115, + 516, + 505, + 529 + ], + "score": 1.0, + "content": "In International Conference on Simulation of Adaptive Behavior, pages 299–309. Springer, 2012.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28.5, + "bbox_fs": [ + 105, + 505, + 505, + 529 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 535, + 504, + 569 + ], + "lines": [ + { + "bbox": [ + 104, + 534, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 104, + 534, + 505, + 549 + ], + "score": 1.0, + "content": "J. Oh, X. Guo, H. Lee, R. L. Lewis, and S. Singh. Action-conditional video prediction using deep", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 114, + 546, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 114, + 546, + 505, + 559 + ], + "score": 1.0, + "content": "networks in atari games. In Advances in Neural Information Processing Systems, pages 2863–", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 556, + 167, + 570 + ], + "spans": [ + { + "bbox": [ + 115, + 556, + 167, + 570 + ], + "score": 1.0, + "content": "2871, 2015.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31, + "bbox_fs": [ + 104, + 534, + 505, + 570 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 576, + 504, + 601 + ], + "lines": [ + { + "bbox": [ + 105, + 577, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 505, + 590 + ], + "score": 1.0, + "content": "T. Schaul and M. B. Ring. Better Generalization with Forecasts. In Proceedings of the International", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 116, + 588, + 411, + 601 + ], + "spans": [ + { + "bbox": [ + 116, + 588, + 411, + 601 + ], + "score": 1.0, + "content": "Joint Conference on Artificial Intelligence (IJCAI), Beijing, China, 2013.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 577, + 505, + 601 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 607, + 504, + 631 + ], + "lines": [ + { + "bbox": [ + 106, + 606, + 505, + 620 + ], + "spans": [ + { + "bbox": [ + 106, + 606, + 505, + 620 + ], + "score": 1.0, + "content": "T. Schaul, D. Horgan, K. Gregor, and D. Silver. Universal Value Function Approximators. In", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 618, + 369, + 631 + ], + "spans": [ + { + "bbox": [ + 116, + 618, + 369, + 631 + ], + "score": 1.0, + "content": "International Conference on Machine Learning (ICML), 2015.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5, + "bbox_fs": [ + 106, + 606, + 505, + 631 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 637, + 504, + 672 + ], + "lines": [ + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "J. Schmidhuber. On learning to think: Algorithmic information theory for novel combina-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 116, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 116, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "tions of reinforcement learning controllers and recurrent neural world models. arXiv preprint", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 659, + 219, + 672 + ], + "spans": [ + { + "bbox": [ + 116, + 659, + 219, + 672 + ], + "score": 1.0, + "content": "arXiv:1511.09249, 2015.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 637, + 505, + 672 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 679, + 502, + 702 + ], + "lines": [ + { + "bbox": [ + 105, + 678, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 505, + 693 + ], + "score": 1.0, + "content": "R. S. Sutton. Learning to predict by the methods of temporal differences. Machine Learning, 3:", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 116, + 690, + 166, + 702 + ], + "spans": [ + { + "bbox": [ + 116, + 690, + 166, + 702 + ], + "score": 1.0, + "content": "9–44, 1988.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5, + "bbox_fs": [ + 105, + 678, + 505, + 702 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 502, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 504, + 722 + ], + "score": 1.0, + "content": "R. S. Sutton. TD models: Modeling the world at a mixture of time scales. In Proceedings of the", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 720, + 433, + 733 + ], + "spans": [ + { + "bbox": [ + 115, + 720, + 433, + 733 + ], + "score": 1.0, + "content": "Twelfth International Conference on Machine Learning, pages 531–539, 1995.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5, + "bbox_fs": [ + 105, + 709, + 504, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 104, + 80, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 104, + 80, + 505, + 96 + ], + "score": 1.0, + "content": "R. S. Sutton and A. G. Barto. Reinforcement Learning: An Introduction. The MIT press, Cambridge", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 93, + 162, + 105 + ], + "spans": [ + { + "bbox": [ + 115, + 93, + 162, + 105 + ], + "score": 1.0, + "content": "MA, 1998.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 106, + 111, + 505, + 156 + ], + "lines": [ + { + "bbox": [ + 105, + 112, + 505, + 125 + ], + "spans": [ + { + "bbox": [ + 105, + 112, + 505, + 125 + ], + "score": 1.0, + "content": "R. S. Sutton, J. Modayil, M. Delp, T. Degris, P. M. Pilarski, A. White, and D. Precup. Horde: A scal-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 116, + 124, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 116, + 124, + 505, + 136 + ], + "score": 1.0, + "content": "able real-time architecture for learning knowledge from unsupervised sensorimotor interaction.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 114, + 133, + 506, + 147 + ], + "spans": [ + { + "bbox": [ + 114, + 133, + 506, + 147 + ], + "score": 1.0, + "content": "In The 10th International Conference on Autonomous Agents and Multiagent Systems-Volume 2,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 145, + 505, + 158 + ], + "spans": [ + { + "bbox": [ + 115, + 145, + 505, + 158 + ], + "score": 1.0, + "content": "pages 761–768. International Foundation for Autonomous Agents and Multiagent Systems, 2011.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 106, + 163, + 503, + 187 + ], + "lines": [ + { + "bbox": [ + 106, + 163, + 505, + 176 + ], + "spans": [ + { + "bbox": [ + 106, + 163, + 505, + 176 + ], + "score": 1.0, + "content": "A. Tamar, Y. Wu, G. Thomas, S. Levine, and P. Abbeel. Value iteration networks. In Neural", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 175, + 305, + 187 + ], + "spans": [ + { + "bbox": [ + 115, + 175, + 305, + 187 + ], + "score": 1.0, + "content": "Information Processing Systems (NIPS), 2016.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 107, + 194, + 506, + 227 + ], + "lines": [ + { + "bbox": [ + 106, + 194, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 106, + 194, + 505, + 206 + ], + "score": 1.0, + "content": "E. Todorov, T. Erez, and Y. Tassa. Mujoco: A physics engine for model-based control. In 2012", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 204, + 505, + 217 + ], + "spans": [ + { + "bbox": [ + 115, + 204, + 505, + 217 + ], + "score": 1.0, + "content": "IEEE/RSJ International Conference on Intelligent Robots and Systems, pages 5026–5033. IEEE,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 214, + 143, + 229 + ], + "spans": [ + { + "bbox": [ + 115, + 214, + 143, + 229 + ], + "score": 1.0, + "content": "2012.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + } + ], + "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": "text", + "bbox": [ + 105, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 104, + 80, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 104, + 80, + 505, + 96 + ], + "score": 1.0, + "content": "R. S. Sutton and A. G. Barto. Reinforcement Learning: An Introduction. The MIT press, Cambridge", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 93, + 162, + 105 + ], + "spans": [ + { + "bbox": [ + 115, + 93, + 162, + 105 + ], + "score": 1.0, + "content": "MA, 1998.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 104, + 80, + 505, + 105 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 111, + 505, + 156 + ], + "lines": [ + { + "bbox": [ + 105, + 112, + 505, + 125 + ], + "spans": [ + { + "bbox": [ + 105, + 112, + 505, + 125 + ], + "score": 1.0, + "content": "R. S. Sutton, J. Modayil, M. Delp, T. Degris, P. M. Pilarski, A. White, and D. Precup. Horde: A scal-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 116, + 124, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 116, + 124, + 505, + 136 + ], + "score": 1.0, + "content": "able real-time architecture for learning knowledge from unsupervised sensorimotor interaction.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 114, + 133, + 506, + 147 + ], + "spans": [ + { + "bbox": [ + 114, + 133, + 506, + 147 + ], + "score": 1.0, + "content": "In The 10th International Conference on Autonomous Agents and Multiagent Systems-Volume 2,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 145, + 505, + 158 + ], + "spans": [ + { + "bbox": [ + 115, + 145, + 505, + 158 + ], + "score": 1.0, + "content": "pages 761–768. International Foundation for Autonomous Agents and Multiagent Systems, 2011.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 112, + 506, + 158 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 163, + 503, + 187 + ], + "lines": [ + { + "bbox": [ + 106, + 163, + 505, + 176 + ], + "spans": [ + { + "bbox": [ + 106, + 163, + 505, + 176 + ], + "score": 1.0, + "content": "A. Tamar, Y. Wu, G. Thomas, S. Levine, and P. Abbeel. Value iteration networks. In Neural", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 175, + 305, + 187 + ], + "spans": [ + { + "bbox": [ + 115, + 175, + 305, + 187 + ], + "score": 1.0, + "content": "Information Processing Systems (NIPS), 2016.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5, + "bbox_fs": [ + 106, + 163, + 505, + 187 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 194, + 506, + 227 + ], + "lines": [ + { + "bbox": [ + 106, + 194, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 106, + 194, + 505, + 206 + ], + "score": 1.0, + "content": "E. Todorov, T. Erez, and Y. Tassa. Mujoco: A physics engine for model-based control. In 2012", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 204, + 505, + 217 + ], + "spans": [ + { + "bbox": [ + 115, + 204, + 505, + 217 + ], + "score": 1.0, + "content": "IEEE/RSJ International Conference on Intelligent Robots and Systems, pages 5026–5033. IEEE,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 214, + 143, + 229 + ], + "spans": [ + { + "bbox": [ + 115, + 214, + 143, + 229 + ], + "score": 1.0, + "content": "2012.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9, + "bbox_fs": [ + 106, + 194, + 505, + 229 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 266, + 81, + 341, + 234 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 266, + 81, + 341, + 234 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 266, + 81, + 341, + 234 + ], + "spans": [ + { + "bbox": [ + 266, + 81, + 341, + 234 + ], + "score": 0.955, + "type": "image", + "image_path": "470c195ad3d74763aaa60fca5f7047608345478b942bb4154c2bfe8bc163ff2a.jpg" + } + ] + } + ], + "index": 0, + "virtual_lines": [ + { + "bbox": [ + 266, + 81, + 341, + 234 + ], + "spans": [], + "index": 0 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 195, + 247, + 415, + 259 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 194, + 245, + 416, + 261 + ], + "spans": [ + { + "bbox": [ + 194, + 245, + 416, + 261 + ], + "score": 1.0, + "content": "Figure 7: The predictron core used in our experiments.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "title", + "bbox": [ + 108, + 279, + 210, + 291 + ], + "lines": [ + { + "bbox": [ + 105, + 277, + 212, + 293 + ], + "spans": [ + { + "bbox": [ + 105, + 277, + 212, + 293 + ], + "score": 1.0, + "content": "A ARCHITECTURE", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 107, + 300, + 505, + 367 + ], + "lines": [ + { + "bbox": [ + 106, + 300, + 506, + 313 + ], + "spans": [ + { + "bbox": [ + 106, + 300, + 205, + 313 + ], + "score": 1.0, + "content": "The state representation", + "type": "text" + }, + { + "bbox": [ + 205, + 301, + 213, + 312 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 300, + 506, + 313 + ], + "score": 1.0, + "content": "is a two-layer convolutional neural network (LeCun et al., 1998). There", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 311, + 506, + 323 + ], + "spans": [ + { + "bbox": [ + 105, + 311, + 146, + 323 + ], + "score": 1.0, + "content": "is a core", + "type": "text" + }, + { + "bbox": [ + 146, + 314, + 152, + 321 + ], + "score": 0.4, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 311, + 433, + 323 + ], + "score": 1.0, + "content": ", again based on convolutions, that combines both MRP model and", + "type": "text" + }, + { + "bbox": [ + 433, + 312, + 441, + 321 + ], + "score": 0.79, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 441, + 311, + 506, + 323 + ], + "score": 1.0, + "content": "-network into a", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 104, + 320, + 507, + 335 + ], + "spans": [ + { + "bbox": [ + 104, + 320, + 252, + 335 + ], + "score": 1.0, + "content": "single repeatable module, such that", + "type": "text" + }, + { + "bbox": [ + 252, + 321, + 374, + 334 + ], + "score": 0.88, + "content": "\\mathbf { s } ^ { k + 1 } , \\mathbf { r } ^ { k + 1 } , \\gamma ^ { k + 1 } , \\lambda ^ { k } = c ( \\mathbf { s } ^ { k } )", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 320, + 507, + 335 + ], + "score": 1.0, + "content": ". This core is deterministic, and", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 333, + 505, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 333, + 159, + 345 + ], + "score": 1.0, + "content": "is duplicated", + "type": "text" + }, + { + "bbox": [ + 159, + 334, + 170, + 343 + ], + "score": 0.8, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 333, + 505, + 345 + ], + "score": 1.0, + "content": "times in the predictron with shared weights. (The predictron with unshared weights", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 104, + 343, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 104, + 343, + 122, + 358 + ], + "score": 1.0, + "content": "has", + "type": "text" + }, + { + "bbox": [ + 122, + 344, + 132, + 354 + ], + "score": 0.82, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 343, + 299, + 358 + ], + "score": 1.0, + "content": "distinct cores.) Finally, the value network", + "type": "text" + }, + { + "bbox": [ + 299, + 346, + 306, + 354 + ], + "score": 0.75, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 343, + 506, + 358 + ], + "score": 1.0, + "content": "is a fully connected neural network that computes", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 352, + 159, + 368 + ], + "spans": [ + { + "bbox": [ + 106, + 354, + 154, + 367 + ], + "score": 0.93, + "content": "\\mathbf { v } ^ { k } = v ( \\mathbf { s } ^ { k } )", + "type": "inline_equation" + }, + { + "bbox": [ + 154, + 352, + 159, + 368 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 106, + 369, + 505, + 457 + ], + "lines": [ + { + "bbox": [ + 106, + 369, + 505, + 381 + ], + "spans": [ + { + "bbox": [ + 106, + 369, + 505, + 381 + ], + "score": 1.0, + "content": "Concretely, the core (Figure 7) consists first of a convolutional layer that maps into an intermediate", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 380, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 505, + 392 + ], + "score": 1.0, + "content": "(hidden) layer. From this layer, another two convolutions compute the next abstract state of the", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 391, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 505, + 403 + ], + "score": 1.0, + "content": "predictron. Additionally, this same hidden layer is flattened and fed into three separate networks,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 402, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 505, + 414 + ], + "score": 1.0, + "content": "with two fully connected layers each. The outputs of these three networks represent the internal", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 412, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 505, + 425 + ], + "score": 1.0, + "content": "rewards, discounts, and lambdas. A similar small network also hangs off the internal states, in", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 422, + 506, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 422, + 379, + 436 + ], + "score": 1.0, + "content": "addition to the core, and computes the values. All convolutions use", + "type": "text" + }, + { + "bbox": [ + 379, + 424, + 399, + 434 + ], + "score": 0.88, + "content": "3 \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 422, + 506, + 436 + ], + "score": 1.0, + "content": "filters and a stride of one,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 435, + 504, + 446 + ], + "spans": [ + { + "bbox": [ + 106, + 435, + 504, + 446 + ], + "score": 1.0, + "content": "and use padding to retain the size of the feature maps. All feature maps have 32 channels. The", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 446, + 319, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 319, + 457 + ], + "score": 1.0, + "content": "hidden layers within the MLPs have 32 hidden units.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 108, + 459, + 502, + 492 + ], + "lines": [ + { + "bbox": [ + 105, + 459, + 504, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 504, + 472 + ], + "score": 1.0, + "content": "In Figure 7 the convolutional layers are schematically drawn with three channels, flattening is repre-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 471, + 504, + 483 + ], + "spans": [ + { + "bbox": [ + 106, + 471, + 504, + 483 + ], + "score": 1.0, + "content": "sented by curly brakets, while the arrows represent the small multi-layer perceptrons which compute", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 482, + 268, + 493 + ], + "spans": [ + { + "bbox": [ + 106, + 482, + 268, + 493 + ], + "score": 1.0, + "content": "values, rewards, discounts and lambdas.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 495, + 505, + 561 + ], + "lines": [ + { + "bbox": [ + 106, + 495, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 495, + 505, + 507 + ], + "score": 1.0, + "content": "We allow up to 16 model steps in our experiments, resulting in 52-layer deep networks—two convo-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 506, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 280, + 518 + ], + "score": 1.0, + "content": "lutional layers for the state representations,", + "type": "text" + }, + { + "bbox": [ + 280, + 506, + 331, + 516 + ], + "score": 0.91, + "content": "3 \\times 1 6 = 4 8", + "type": "inline_equation" + }, + { + "bbox": [ + 332, + 506, + 505, + 518 + ], + "score": 1.0, + "content": "convolutional layers for the core steps, and", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 516, + 505, + 531 + ], + "spans": [ + { + "bbox": [ + 104, + 516, + 505, + 531 + ], + "score": 1.0, + "content": "two fully-connected layers for the values on top of the final state. Between each two layers we ap-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 528, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 505, + 540 + ], + "score": 1.0, + "content": "ply batch normalization (Ioffe and Szegedy, 2015) followed by a ReLU non-linearity (Glorot et al.,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 539, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 457, + 551 + ], + "score": 1.0, + "content": "2011). The value and reward networks end with a linear layer, whereas the discount and", + "type": "text" + }, + { + "bbox": [ + 457, + 540, + 464, + 549 + ], + "score": 0.78, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 539, + 505, + 551 + ], + "score": 1.0, + "content": "-networks", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 550, + 439, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 414, + 563 + ], + "score": 1.0, + "content": "additionally add a sigmoid non-linearity to ensure that these quantities are in", + "type": "text" + }, + { + "bbox": [ + 415, + 550, + 435, + 562 + ], + "score": 0.43, + "content": "[ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 435, + 550, + 439, + 563 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22.5 + }, + { + "type": "title", + "bbox": [ + 107, + 574, + 180, + 587 + ], + "lines": [ + { + "bbox": [ + 104, + 573, + 182, + 589 + ], + "spans": [ + { + "bbox": [ + 104, + 573, + 182, + 589 + ], + "score": 1.0, + "content": "B TRAINING", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 596, + 505, + 674 + ], + "lines": [ + { + "bbox": [ + 106, + 597, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 597, + 505, + 609 + ], + "score": 1.0, + "content": "All experiments used the supervised (Monte-Carlo) update described in Section 4 except for the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 608, + 505, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 608, + 505, + 620 + ], + "score": 1.0, + "content": "semi-supervised experiment which used the consistency update described in Section 4.1. We update", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 618, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 506, + 632 + ], + "score": 1.0, + "content": "all parameters by applying the Adam optimiser (Kingma and Ba, 2015) to stochastic gradients of", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 630, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 106, + 630, + 505, + 642 + ], + "score": 1.0, + "content": "the corresponding loss functions. Each return is normalised by dividing it by its standard deviation", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 640, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 104, + 640, + 505, + 654 + ], + "score": 1.0, + "content": "(as measured, prior to the experiment, on a set of 20,000 episodes). In all experiments, the learning", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 651, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 390, + 664 + ], + "score": 1.0, + "content": "rate was 0.001, and the other parameters of the Adam optimiser were", + "type": "text" + }, + { + "bbox": [ + 391, + 651, + 430, + 663 + ], + "score": 0.87, + "content": "\\beta _ { 1 } = 0 . 9", + "type": "inline_equation" + }, + { + "bbox": [ + 430, + 652, + 434, + 664 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 434, + 651, + 484, + 663 + ], + "score": 0.87, + "content": "\\beta _ { 2 } = 0 . 9 9 9", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 652, + 505, + 664 + ], + "score": 1.0, + "content": ", and", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 661, + 306, + 676 + ], + "spans": [ + { + "bbox": [ + 106, + 662, + 145, + 673 + ], + "score": 0.91, + "content": "\\epsilon = 1 0 ^ { - 8 }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 661, + 306, + 676 + ], + "score": 1.0, + "content": ". We used mini-batches of 100 samples.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 30 + }, + { + "type": "title", + "bbox": [ + 107, + 688, + 399, + 700 + ], + "lines": [ + { + "bbox": [ + 105, + 686, + 400, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 400, + 702 + ], + "score": 1.0, + "content": "C COMPARING ARCHITECTURES OF DIFFERENT DEPTHS", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 501, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 503, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 503, + 722 + ], + "score": 1.0, + "content": "We investigated the effect of changing the depth of the networks, with and without skip connec-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 720, + 504, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 504, + 733 + ], + "score": 1.0, + "content": "tions. Figure 8 in shows that skip connections (dashed lines) make the conventional architectures", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 266, + 81, + 341, + 234 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 266, + 81, + 341, + 234 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 266, + 81, + 341, + 234 + ], + "spans": [ + { + "bbox": [ + 266, + 81, + 341, + 234 + ], + "score": 0.955, + "type": "image", + "image_path": "470c195ad3d74763aaa60fca5f7047608345478b942bb4154c2bfe8bc163ff2a.jpg" + } + ] + } + ], + "index": 0, + "virtual_lines": [ + { + "bbox": [ + 266, + 81, + 341, + 234 + ], + "spans": [], + "index": 0 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 195, + 247, + 415, + 259 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 194, + 245, + 416, + 261 + ], + "spans": [ + { + "bbox": [ + 194, + 245, + 416, + 261 + ], + "score": 1.0, + "content": "Figure 7: The predictron core used in our experiments.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "title", + "bbox": [ + 108, + 279, + 210, + 291 + ], + "lines": [ + { + "bbox": [ + 105, + 277, + 212, + 293 + ], + "spans": [ + { + "bbox": [ + 105, + 277, + 212, + 293 + ], + "score": 1.0, + "content": "A ARCHITECTURE", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 107, + 300, + 505, + 367 + ], + "lines": [ + { + "bbox": [ + 106, + 300, + 506, + 313 + ], + "spans": [ + { + "bbox": [ + 106, + 300, + 205, + 313 + ], + "score": 1.0, + "content": "The state representation", + "type": "text" + }, + { + "bbox": [ + 205, + 301, + 213, + 312 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 300, + 506, + 313 + ], + "score": 1.0, + "content": "is a two-layer convolutional neural network (LeCun et al., 1998). There", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 311, + 506, + 323 + ], + "spans": [ + { + "bbox": [ + 105, + 311, + 146, + 323 + ], + "score": 1.0, + "content": "is a core", + "type": "text" + }, + { + "bbox": [ + 146, + 314, + 152, + 321 + ], + "score": 0.4, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 311, + 433, + 323 + ], + "score": 1.0, + "content": ", again based on convolutions, that combines both MRP model and", + "type": "text" + }, + { + "bbox": [ + 433, + 312, + 441, + 321 + ], + "score": 0.79, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 441, + 311, + 506, + 323 + ], + "score": 1.0, + "content": "-network into a", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 104, + 320, + 507, + 335 + ], + "spans": [ + { + "bbox": [ + 104, + 320, + 252, + 335 + ], + "score": 1.0, + "content": "single repeatable module, such that", + "type": "text" + }, + { + "bbox": [ + 252, + 321, + 374, + 334 + ], + "score": 0.88, + "content": "\\mathbf { s } ^ { k + 1 } , \\mathbf { r } ^ { k + 1 } , \\gamma ^ { k + 1 } , \\lambda ^ { k } = c ( \\mathbf { s } ^ { k } )", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 320, + 507, + 335 + ], + "score": 1.0, + "content": ". This core is deterministic, and", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 333, + 505, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 333, + 159, + 345 + ], + "score": 1.0, + "content": "is duplicated", + "type": "text" + }, + { + "bbox": [ + 159, + 334, + 170, + 343 + ], + "score": 0.8, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 333, + 505, + 345 + ], + "score": 1.0, + "content": "times in the predictron with shared weights. (The predictron with unshared weights", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 104, + 343, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 104, + 343, + 122, + 358 + ], + "score": 1.0, + "content": "has", + "type": "text" + }, + { + "bbox": [ + 122, + 344, + 132, + 354 + ], + "score": 0.82, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 343, + 299, + 358 + ], + "score": 1.0, + "content": "distinct cores.) Finally, the value network", + "type": "text" + }, + { + "bbox": [ + 299, + 346, + 306, + 354 + ], + "score": 0.75, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 343, + 506, + 358 + ], + "score": 1.0, + "content": "is a fully connected neural network that computes", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 352, + 159, + 368 + ], + "spans": [ + { + "bbox": [ + 106, + 354, + 154, + 367 + ], + "score": 0.93, + "content": "\\mathbf { v } ^ { k } = v ( \\mathbf { s } ^ { k } )", + "type": "inline_equation" + }, + { + "bbox": [ + 154, + 352, + 159, + 368 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.5, + "bbox_fs": [ + 104, + 300, + 507, + 368 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 369, + 505, + 457 + ], + "lines": [ + { + "bbox": [ + 106, + 369, + 505, + 381 + ], + "spans": [ + { + "bbox": [ + 106, + 369, + 505, + 381 + ], + "score": 1.0, + "content": "Concretely, the core (Figure 7) consists first of a convolutional layer that maps into an intermediate", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 380, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 505, + 392 + ], + "score": 1.0, + "content": "(hidden) layer. From this layer, another two convolutions compute the next abstract state of the", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 391, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 505, + 403 + ], + "score": 1.0, + "content": "predictron. Additionally, this same hidden layer is flattened and fed into three separate networks,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 402, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 505, + 414 + ], + "score": 1.0, + "content": "with two fully connected layers each. The outputs of these three networks represent the internal", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 412, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 505, + 425 + ], + "score": 1.0, + "content": "rewards, discounts, and lambdas. A similar small network also hangs off the internal states, in", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 422, + 506, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 422, + 379, + 436 + ], + "score": 1.0, + "content": "addition to the core, and computes the values. All convolutions use", + "type": "text" + }, + { + "bbox": [ + 379, + 424, + 399, + 434 + ], + "score": 0.88, + "content": "3 \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 422, + 506, + 436 + ], + "score": 1.0, + "content": "filters and a stride of one,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 435, + 504, + 446 + ], + "spans": [ + { + "bbox": [ + 106, + 435, + 504, + 446 + ], + "score": 1.0, + "content": "and use padding to retain the size of the feature maps. All feature maps have 32 channels. The", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 446, + 319, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 319, + 457 + ], + "score": 1.0, + "content": "hidden layers within the MLPs have 32 hidden units.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 12.5, + "bbox_fs": [ + 105, + 369, + 506, + 457 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 459, + 502, + 492 + ], + "lines": [ + { + "bbox": [ + 105, + 459, + 504, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 504, + 472 + ], + "score": 1.0, + "content": "In Figure 7 the convolutional layers are schematically drawn with three channels, flattening is repre-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 471, + 504, + 483 + ], + "spans": [ + { + "bbox": [ + 106, + 471, + 504, + 483 + ], + "score": 1.0, + "content": "sented by curly brakets, while the arrows represent the small multi-layer perceptrons which compute", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 482, + 268, + 493 + ], + "spans": [ + { + "bbox": [ + 106, + 482, + 268, + 493 + ], + "score": 1.0, + "content": "values, rewards, discounts and lambdas.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 459, + 504, + 493 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 495, + 505, + 561 + ], + "lines": [ + { + "bbox": [ + 106, + 495, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 495, + 505, + 507 + ], + "score": 1.0, + "content": "We allow up to 16 model steps in our experiments, resulting in 52-layer deep networks—two convo-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 506, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 280, + 518 + ], + "score": 1.0, + "content": "lutional layers for the state representations,", + "type": "text" + }, + { + "bbox": [ + 280, + 506, + 331, + 516 + ], + "score": 0.91, + "content": "3 \\times 1 6 = 4 8", + "type": "inline_equation" + }, + { + "bbox": [ + 332, + 506, + 505, + 518 + ], + "score": 1.0, + "content": "convolutional layers for the core steps, and", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 516, + 505, + 531 + ], + "spans": [ + { + "bbox": [ + 104, + 516, + 505, + 531 + ], + "score": 1.0, + "content": "two fully-connected layers for the values on top of the final state. Between each two layers we ap-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 528, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 505, + 540 + ], + "score": 1.0, + "content": "ply batch normalization (Ioffe and Szegedy, 2015) followed by a ReLU non-linearity (Glorot et al.,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 539, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 457, + 551 + ], + "score": 1.0, + "content": "2011). The value and reward networks end with a linear layer, whereas the discount and", + "type": "text" + }, + { + "bbox": [ + 457, + 540, + 464, + 549 + ], + "score": 0.78, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 539, + 505, + 551 + ], + "score": 1.0, + "content": "-networks", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 550, + 439, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 414, + 563 + ], + "score": 1.0, + "content": "additionally add a sigmoid non-linearity to ensure that these quantities are in", + "type": "text" + }, + { + "bbox": [ + 415, + 550, + 435, + 562 + ], + "score": 0.43, + "content": "[ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 435, + 550, + 439, + 563 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22.5, + "bbox_fs": [ + 104, + 495, + 505, + 563 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 574, + 180, + 587 + ], + "lines": [ + { + "bbox": [ + 104, + 573, + 182, + 589 + ], + "spans": [ + { + "bbox": [ + 104, + 573, + 182, + 589 + ], + "score": 1.0, + "content": "B TRAINING", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 596, + 505, + 674 + ], + "lines": [ + { + "bbox": [ + 106, + 597, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 597, + 505, + 609 + ], + "score": 1.0, + "content": "All experiments used the supervised (Monte-Carlo) update described in Section 4 except for the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 608, + 505, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 608, + 505, + 620 + ], + "score": 1.0, + "content": "semi-supervised experiment which used the consistency update described in Section 4.1. We update", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 618, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 506, + 632 + ], + "score": 1.0, + "content": "all parameters by applying the Adam optimiser (Kingma and Ba, 2015) to stochastic gradients of", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 630, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 106, + 630, + 505, + 642 + ], + "score": 1.0, + "content": "the corresponding loss functions. Each return is normalised by dividing it by its standard deviation", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 640, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 104, + 640, + 505, + 654 + ], + "score": 1.0, + "content": "(as measured, prior to the experiment, on a set of 20,000 episodes). In all experiments, the learning", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 651, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 390, + 664 + ], + "score": 1.0, + "content": "rate was 0.001, and the other parameters of the Adam optimiser were", + "type": "text" + }, + { + "bbox": [ + 391, + 651, + 430, + 663 + ], + "score": 0.87, + "content": "\\beta _ { 1 } = 0 . 9", + "type": "inline_equation" + }, + { + "bbox": [ + 430, + 652, + 434, + 664 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 434, + 651, + 484, + 663 + ], + "score": 0.87, + "content": "\\beta _ { 2 } = 0 . 9 9 9", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 652, + 505, + 664 + ], + "score": 1.0, + "content": ", and", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 661, + 306, + 676 + ], + "spans": [ + { + "bbox": [ + 106, + 662, + 145, + 673 + ], + "score": 0.91, + "content": "\\epsilon = 1 0 ^ { - 8 }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 661, + 306, + 676 + ], + "score": 1.0, + "content": ". We used mini-batches of 100 samples.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 30, + "bbox_fs": [ + 104, + 597, + 506, + 676 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 688, + 399, + 700 + ], + "lines": [ + { + "bbox": [ + 105, + 686, + 400, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 400, + 702 + ], + "score": 1.0, + "content": "C COMPARING ARCHITECTURES OF DIFFERENT DEPTHS", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 501, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 503, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 503, + 722 + ], + "score": 1.0, + "content": "We investigated the effect of changing the depth of the networks, with and without skip connec-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 720, + 504, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 504, + 733 + ], + "score": 1.0, + "content": "tions. Figure 8 in shows that skip connections (dashed lines) make the conventional architectures", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 708, + 504, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 151, + 84, + 453, + 273 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 151, + 84, + 453, + 273 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 151, + 84, + 453, + 273 + ], + "spans": [ + { + "bbox": [ + 151, + 84, + 453, + 273 + ], + "score": 0.975, + "type": "image", + "image_path": "b6658dee23cb96957d5c8447b1e18b5490b5e092b78dedcaac61ba8d741f03c4.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 151, + 84, + 453, + 147.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 151, + 147.0, + 453, + 210.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 151, + 210.0, + 453, + 273.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 291, + 505, + 336 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 291, + 506, + 305 + ], + "spans": [ + { + "bbox": [ + 105, + 291, + 295, + 305 + ], + "score": 1.0, + "content": "Figure 8: Comparing depths. Comparing the", + "type": "text" + }, + { + "bbox": [ + 295, + 291, + 328, + 303 + ], + "score": 0.93, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 328, + 291, + 506, + 305 + ], + "score": 1.0, + "content": "-predictron (red) against more conventional", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 303, + 505, + 314 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 505, + 314 + ], + "score": 1.0, + "content": "deep networks (black) for various depths (2, 4, 8, or 16 model steps, corresponding to 10, 16, 28, or", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 313, + 506, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 506, + 326 + ], + "score": 1.0, + "content": "52 total layers of depth). Lighter colours correspond to shallower networks. Dashed lines correspond", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 324, + 248, + 337 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 248, + 337 + ], + "score": 1.0, + "content": "to networks with skip connections.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "text", + "bbox": [ + 107, + 361, + 505, + 394 + ], + "lines": [ + { + "bbox": [ + 105, + 360, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 505, + 375 + ], + "score": 1.0, + "content": "(black/grey lines) more robust to the depth (i.e., the black/grey dashed lines almost overlap, es-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 372, + 506, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 506, + 385 + ], + "score": 1.0, + "content": "pecially on pool), and that the predictron outperforms the corresponding feedforward or recurrent", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 383, + 298, + 396 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 298, + 396 + ], + "score": 1.0, + "content": "baselines for all depths, with and without skips.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8 + }, + { + "type": "title", + "bbox": [ + 108, + 413, + 258, + 425 + ], + "lines": [ + { + "bbox": [ + 105, + 412, + 260, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 260, + 427 + ], + "score": 1.0, + "content": "D CAPACITY COMPARISONS", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 437, + 505, + 493 + ], + "lines": [ + { + "bbox": [ + 105, + 438, + 505, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 438, + 505, + 451 + ], + "score": 1.0, + "content": "In this section, we present some additional experiments comparing the predictron to more con-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 449, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 449, + 505, + 461 + ], + "score": 1.0, + "content": "ventional deep networks. The purposes of these experiments are 1) to show that the conclusions", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 459, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 506, + 473 + ], + "score": 1.0, + "content": "obtained above do not depend on the precise architecture used, and 2) to show that the structure", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 470, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 506, + 484 + ], + "score": 1.0, + "content": "of the network—whether we use a predictron or not—is more important than the raw number of", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 483, + 155, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 155, + 494 + ], + "score": 1.0, + "content": "parameters.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 496, + 504, + 551 + ], + "lines": [ + { + "bbox": [ + 105, + 495, + 506, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 506, + 507 + ], + "score": 1.0, + "content": "Specifically, we again consider the same 20 by 20 random mazes, and the pool task described in the", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 506, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 505, + 518 + ], + "score": 1.0, + "content": "main text. As described in Section A, for the results in the paper we used an encoder that preserved", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 518, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 216, + 529 + ], + "score": 1.0, + "content": "the size of the input plans,", + "type": "text" + }, + { + "bbox": [ + 217, + 518, + 251, + 528 + ], + "score": 0.9, + "content": "2 0 \\times 2 0", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 518, + 327, + 529 + ], + "score": 1.0, + "content": "for the mazes and", + "type": "text" + }, + { + "bbox": [ + 327, + 518, + 362, + 528 + ], + "score": 0.89, + "content": "2 8 \\times 2 8", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 518, + 505, + 529 + ], + "score": 1.0, + "content": "for pool. Each convolution had 32", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 528, + 506, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 298, + 540 + ], + "score": 1.0, + "content": "channels and therefore the abstract states were", + "type": "text" + }, + { + "bbox": [ + 298, + 529, + 355, + 539 + ], + "score": 0.92, + "content": "2 0 \\times 2 0 \\times 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 528, + 432, + 540 + ], + "score": 1.0, + "content": "for the mazes and", + "type": "text" + }, + { + "bbox": [ + 432, + 529, + 489, + 539 + ], + "score": 0.91, + "content": "2 8 \\times 2 8 \\times 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 490, + 528, + 506, + 540 + ], + "score": 1.0, + "content": "for", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 103, + 540, + 130, + 552 + ], + "spans": [ + { + "bbox": [ + 103, + 540, + 130, + 552 + ], + "score": 1.0, + "content": "pool.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 106, + 553, + 505, + 620 + ], + "lines": [ + { + "bbox": [ + 106, + 554, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 554, + 505, + 565 + ], + "score": 1.0, + "content": "We now consider a different architecture, where we no longer pad the convolutions used in the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 564, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 106, + 564, + 316, + 576 + ], + "score": 1.0, + "content": "encoder. For the mazes, we still use two layers of", + "type": "text" + }, + { + "bbox": [ + 316, + 565, + 341, + 575 + ], + "score": 0.9, + "content": "3 \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 564, + 505, + 576 + ], + "score": 1.0, + "content": "stride-1 convolutions, which means the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 575, + 506, + 587 + ], + "spans": [ + { + "bbox": [ + 105, + 575, + 201, + 587 + ], + "score": 1.0, + "content": "planes reduce in size to", + "type": "text" + }, + { + "bbox": [ + 202, + 576, + 235, + 586 + ], + "score": 0.9, + "content": "1 6 \\times 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 575, + 506, + 587 + ], + "score": 1.0, + "content": ". This means that the abstract states are about one third smaller. For", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 586, + 504, + 598 + ], + "spans": [ + { + "bbox": [ + 106, + 586, + 180, + 598 + ], + "score": 1.0, + "content": "pool, we use three", + "type": "text" + }, + { + "bbox": [ + 181, + 587, + 202, + 597 + ], + "score": 0.9, + "content": "5 \\times 5", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 586, + 373, + 598 + ], + "score": 1.0, + "content": "stride-1 convolutions, which bring us from", + "type": "text" + }, + { + "bbox": [ + 374, + 586, + 405, + 597 + ], + "score": 0.91, + "content": "2 8 \\times 2 8", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 586, + 440, + 598 + ], + "score": 1.0, + "content": "down to", + "type": "text" + }, + { + "bbox": [ + 440, + 586, + 471, + 597 + ], + "score": 0.91, + "content": "1 6 \\times 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 472, + 586, + 504, + 598 + ], + "score": 1.0, + "content": "as well.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 597, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 597, + 505, + 609 + ], + "score": 1.0, + "content": "So, the abstract states are now of equal size for both experiments. For pool, this is approximately a", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 608, + 425, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 608, + 425, + 620 + ], + "score": 1.0, + "content": "two-thirds reduction, which helps reduce the compute needed to run the model.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 106, + 622, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 104, + 620, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 104, + 620, + 505, + 635 + ], + "score": 1.0, + "content": "Most of the parameters in the predictron are in the fully connected layers. Previously, the first fully", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 395, + 646 + ], + "score": 1.0, + "content": "connected layer for each of the internal values, rewards, discounts, and", + "type": "text" + }, + { + "bbox": [ + 395, + 633, + 402, + 643 + ], + "score": 0.75, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 403, + 633, + 506, + 646 + ], + "score": 1.0, + "content": "-parameters would take a", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 643, + 506, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 643, + 506, + 656 + ], + "score": 1.0, + "content": "flattened abstract state, and then go into 32 hidden nodes. This means the number of parameters in", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 167, + 667 + ], + "score": 1.0, + "content": "this layer were", + "type": "text" + }, + { + "bbox": [ + 167, + 655, + 281, + 666 + ], + "score": 0.88, + "content": "2 0 \\times 2 0 \\times 3 2 \\times 3 2 = 4 0 9 , 6", + "type": "inline_equation" + }, + { + "bbox": [ + 282, + 655, + 366, + 667 + ], + "score": 1.0, + "content": "00 for the mazes and", + "type": "text" + }, + { + "bbox": [ + 366, + 655, + 484, + 666 + ], + "score": 0.9, + "content": "2 8 \\times 2 8 \\times 3 2 \\times 3 2 = 8 0 2 , 8 1", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "6 for", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "score": 1.0, + "content": "pool. The predictron with shared core would have four of these layers, one for each of the internal", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 677, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 231, + 690 + ], + "score": 1.0, + "content": "values, rewards, discounts, and", + "type": "text" + }, + { + "bbox": [ + 231, + 677, + 242, + 687 + ], + "score": 0.72, + "content": "\\lambda s", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 677, + 506, + 690 + ], + "score": 1.0, + "content": ", compared to one for the deep network which only has values. We", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 270, + 700 + ], + "score": 1.0, + "content": "change this in two ways. First, we add a", + "type": "text" + }, + { + "bbox": [ + 270, + 688, + 294, + 698 + ], + "score": 0.9, + "content": "1 \\times 1", + "type": "inline_equation" + }, + { + "bbox": [ + 294, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "convolution with a stride of 1 and 8 channels before", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "the first fully connected layer for each of these outputs. This reduces the number of channels, and", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "therefore the number of parameters in the subsequent fully-connected layer, by one fourth. Second,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 720, + 378, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 378, + 732 + ], + "score": 1.0, + "content": "we tested three different numbers of hidden nodes: 32, 128, or 512.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 31.5 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "12", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 108, + 27, + 307, + 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" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 151, + 84, + 453, + 273 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 151, + 84, + 453, + 273 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 151, + 84, + 453, + 273 + ], + "spans": [ + { + "bbox": [ + 151, + 84, + 453, + 273 + ], + "score": 0.975, + "type": "image", + "image_path": "b6658dee23cb96957d5c8447b1e18b5490b5e092b78dedcaac61ba8d741f03c4.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 151, + 84, + 453, + 147.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 151, + 147.0, + 453, + 210.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 151, + 210.0, + 453, + 273.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 291, + 505, + 336 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 291, + 506, + 305 + ], + "spans": [ + { + "bbox": [ + 105, + 291, + 295, + 305 + ], + "score": 1.0, + "content": "Figure 8: Comparing depths. Comparing the", + "type": "text" + }, + { + "bbox": [ + 295, + 291, + 328, + 303 + ], + "score": 0.93, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 328, + 291, + 506, + 305 + ], + "score": 1.0, + "content": "-predictron (red) against more conventional", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 303, + 505, + 314 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 505, + 314 + ], + "score": 1.0, + "content": "deep networks (black) for various depths (2, 4, 8, or 16 model steps, corresponding to 10, 16, 28, or", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 313, + 506, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 506, + 326 + ], + "score": 1.0, + "content": "52 total layers of depth). Lighter colours correspond to shallower networks. Dashed lines correspond", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 324, + 248, + 337 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 248, + 337 + ], + "score": 1.0, + "content": "to networks with skip connections.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "text", + "bbox": [ + 107, + 361, + 505, + 394 + ], + "lines": [ + { + "bbox": [ + 105, + 360, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 505, + 375 + ], + "score": 1.0, + "content": "(black/grey lines) more robust to the depth (i.e., the black/grey dashed lines almost overlap, es-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 372, + 506, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 506, + 385 + ], + "score": 1.0, + "content": "pecially on pool), and that the predictron outperforms the corresponding feedforward or recurrent", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 383, + 298, + 396 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 298, + 396 + ], + "score": 1.0, + "content": "baselines for all depths, with and without skips.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 360, + 506, + 396 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 413, + 258, + 425 + ], + "lines": [ + { + "bbox": [ + 105, + 412, + 260, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 260, + 427 + ], + "score": 1.0, + "content": "D CAPACITY COMPARISONS", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 437, + 505, + 493 + ], + "lines": [ + { + "bbox": [ + 105, + 438, + 505, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 438, + 505, + 451 + ], + "score": 1.0, + "content": "In this section, we present some additional experiments comparing the predictron to more con-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 449, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 449, + 505, + 461 + ], + "score": 1.0, + "content": "ventional deep networks. The purposes of these experiments are 1) to show that the conclusions", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 459, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 506, + 473 + ], + "score": 1.0, + "content": "obtained above do not depend on the precise architecture used, and 2) to show that the structure", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 470, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 506, + 484 + ], + "score": 1.0, + "content": "of the network—whether we use a predictron or not—is more important than the raw number of", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 483, + 155, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 155, + 494 + ], + "score": 1.0, + "content": "parameters.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13, + "bbox_fs": [ + 105, + 438, + 506, + 494 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 496, + 504, + 551 + ], + "lines": [ + { + "bbox": [ + 105, + 495, + 506, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 506, + 507 + ], + "score": 1.0, + "content": "Specifically, we again consider the same 20 by 20 random mazes, and the pool task described in the", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 506, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 505, + 518 + ], + "score": 1.0, + "content": "main text. As described in Section A, for the results in the paper we used an encoder that preserved", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 518, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 216, + 529 + ], + "score": 1.0, + "content": "the size of the input plans,", + "type": "text" + }, + { + "bbox": [ + 217, + 518, + 251, + 528 + ], + "score": 0.9, + "content": "2 0 \\times 2 0", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 518, + 327, + 529 + ], + "score": 1.0, + "content": "for the mazes and", + "type": "text" + }, + { + "bbox": [ + 327, + 518, + 362, + 528 + ], + "score": 0.89, + "content": "2 8 \\times 2 8", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 518, + 505, + 529 + ], + "score": 1.0, + "content": "for pool. Each convolution had 32", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 528, + 506, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 298, + 540 + ], + "score": 1.0, + "content": "channels and therefore the abstract states were", + "type": "text" + }, + { + "bbox": [ + 298, + 529, + 355, + 539 + ], + "score": 0.92, + "content": "2 0 \\times 2 0 \\times 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 528, + 432, + 540 + ], + "score": 1.0, + "content": "for the mazes and", + "type": "text" + }, + { + "bbox": [ + 432, + 529, + 489, + 539 + ], + "score": 0.91, + "content": "2 8 \\times 2 8 \\times 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 490, + 528, + 506, + 540 + ], + "score": 1.0, + "content": "for", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 103, + 540, + 130, + 552 + ], + "spans": [ + { + "bbox": [ + 103, + 540, + 130, + 552 + ], + "score": 1.0, + "content": "pool.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 18, + "bbox_fs": [ + 103, + 495, + 506, + 552 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 553, + 505, + 620 + ], + "lines": [ + { + "bbox": [ + 106, + 554, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 554, + 505, + 565 + ], + "score": 1.0, + "content": "We now consider a different architecture, where we no longer pad the convolutions used in the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 564, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 106, + 564, + 316, + 576 + ], + "score": 1.0, + "content": "encoder. For the mazes, we still use two layers of", + "type": "text" + }, + { + "bbox": [ + 316, + 565, + 341, + 575 + ], + "score": 0.9, + "content": "3 \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 564, + 505, + 576 + ], + "score": 1.0, + "content": "stride-1 convolutions, which means the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 575, + 506, + 587 + ], + "spans": [ + { + "bbox": [ + 105, + 575, + 201, + 587 + ], + "score": 1.0, + "content": "planes reduce in size to", + "type": "text" + }, + { + "bbox": [ + 202, + 576, + 235, + 586 + ], + "score": 0.9, + "content": "1 6 \\times 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 575, + 506, + 587 + ], + "score": 1.0, + "content": ". This means that the abstract states are about one third smaller. For", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 586, + 504, + 598 + ], + "spans": [ + { + "bbox": [ + 106, + 586, + 180, + 598 + ], + "score": 1.0, + "content": "pool, we use three", + "type": "text" + }, + { + "bbox": [ + 181, + 587, + 202, + 597 + ], + "score": 0.9, + "content": "5 \\times 5", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 586, + 373, + 598 + ], + "score": 1.0, + "content": "stride-1 convolutions, which bring us from", + "type": "text" + }, + { + "bbox": [ + 374, + 586, + 405, + 597 + ], + "score": 0.91, + "content": "2 8 \\times 2 8", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 586, + 440, + 598 + ], + "score": 1.0, + "content": "down to", + "type": "text" + }, + { + "bbox": [ + 440, + 586, + 471, + 597 + ], + "score": 0.91, + "content": "1 6 \\times 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 472, + 586, + 504, + 598 + ], + "score": 1.0, + "content": "as well.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 597, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 597, + 505, + 609 + ], + "score": 1.0, + "content": "So, the abstract states are now of equal size for both experiments. For pool, this is approximately a", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 608, + 425, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 608, + 425, + 620 + ], + "score": 1.0, + "content": "two-thirds reduction, which helps reduce the compute needed to run the model.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 554, + 506, + 620 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 622, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 104, + 620, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 104, + 620, + 505, + 635 + ], + "score": 1.0, + "content": "Most of the parameters in the predictron are in the fully connected layers. Previously, the first fully", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 395, + 646 + ], + "score": 1.0, + "content": "connected layer for each of the internal values, rewards, discounts, and", + "type": "text" + }, + { + "bbox": [ + 395, + 633, + 402, + 643 + ], + "score": 0.75, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 403, + 633, + 506, + 646 + ], + "score": 1.0, + "content": "-parameters would take a", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 643, + 506, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 643, + 506, + 656 + ], + "score": 1.0, + "content": "flattened abstract state, and then go into 32 hidden nodes. This means the number of parameters in", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 167, + 667 + ], + "score": 1.0, + "content": "this layer were", + "type": "text" + }, + { + "bbox": [ + 167, + 655, + 281, + 666 + ], + "score": 0.88, + "content": "2 0 \\times 2 0 \\times 3 2 \\times 3 2 = 4 0 9 , 6", + "type": "inline_equation" + }, + { + "bbox": [ + 282, + 655, + 366, + 667 + ], + "score": 1.0, + "content": "00 for the mazes and", + "type": "text" + }, + { + "bbox": [ + 366, + 655, + 484, + 666 + ], + "score": 0.9, + "content": "2 8 \\times 2 8 \\times 3 2 \\times 3 2 = 8 0 2 , 8 1", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "6 for", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "score": 1.0, + "content": "pool. The predictron with shared core would have four of these layers, one for each of the internal", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 677, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 231, + 690 + ], + "score": 1.0, + "content": "values, rewards, discounts, and", + "type": "text" + }, + { + "bbox": [ + 231, + 677, + 242, + 687 + ], + "score": 0.72, + "content": "\\lambda s", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 677, + 506, + 690 + ], + "score": 1.0, + "content": ", compared to one for the deep network which only has values. We", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 270, + 700 + ], + "score": 1.0, + "content": "change this in two ways. First, we add a", + "type": "text" + }, + { + "bbox": [ + 270, + 688, + 294, + 698 + ], + "score": 0.9, + "content": "1 \\times 1", + "type": "inline_equation" + }, + { + "bbox": [ + 294, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "convolution with a stride of 1 and 8 channels before", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "the first fully connected layer for each of these outputs. This reduces the number of channels, and", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "therefore the number of parameters in the subsequent fully-connected layer, by one fourth. Second,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 720, + 378, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 378, + 732 + ], + "score": 1.0, + "content": "we tested three different numbers of hidden nodes: 32, 128, or 512.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 31.5, + "bbox_fs": [ + 104, + 620, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 122, + 81, + 489, + 270 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 122, + 81, + 489, + 270 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 122, + 81, + 489, + 270 + ], + "spans": [ + { + "bbox": [ + 122, + 81, + 489, + 270 + ], + "score": 0.976, + "type": "image", + "image_path": "93fd02c8270d80a1af3e7ef67faee6943d3152147776544fec0ca60f183fb98d.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 122, + 81, + 489, + 144.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 122, + 144.0, + 489, + 207.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 122, + 207.0, + 489, + 270.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 285, + 505, + 362 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 284, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 295, + 299 + ], + "score": 1.0, + "content": "Figure 9: Comparing depths. Comparing the", + "type": "text" + }, + { + "bbox": [ + 295, + 285, + 328, + 298 + ], + "score": 0.93, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 328, + 284, + 506, + 299 + ], + "score": 1.0, + "content": "-predictron (red) against more conventional", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 296, + 505, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 505, + 309 + ], + "score": 1.0, + "content": "deep networks (blue) for different numbers hidden nodes in the fully connected layers, and therefore", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 306, + 505, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 505, + 321 + ], + "score": 1.0, + "content": "different total numbers of parameters. The deep networks with 32, 128, and 512 nodes respectively", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 319, + 505, + 330 + ], + "spans": [ + { + "bbox": [ + 106, + 319, + 505, + 330 + ], + "score": 1.0, + "content": "have 381,416, 1,275,752, and 4,853,096 parameters in total. The predictrons with 32 and 128 nodes", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 330, + 505, + 342 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 505, + 342 + ], + "score": 1.0, + "content": "respectively have 1,275,752, and 4,853,096 parameters in total. Note that the number of parameters", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 340, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 505, + 353 + ], + "score": 1.0, + "content": "for the 32 and 128 node predictrons are exactly equal to the number of parameters for the 128 and", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 351, + 209, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 209, + 365 + ], + "score": 1.0, + "content": "512 node deep networks.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 385, + 505, + 441 + ], + "lines": [ + { + "bbox": [ + 106, + 384, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 106, + 384, + 505, + 397 + ], + "score": 1.0, + "content": "The deep network with 128 hidden nodes for its values has the exact same number of parameters", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 396, + 505, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 133, + 409 + ], + "score": 1.0, + "content": "as the", + "type": "text" + }, + { + "bbox": [ + 134, + 396, + 166, + 408 + ], + "score": 0.93, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 396, + 505, + 409 + ], + "score": 1.0, + "content": "-predictron with 32 hidden nodes for each of its outputs. Before, the deep network", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 406, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 505, + 420 + ], + "score": 1.0, + "content": "had fewer parameters, because we kept this number fixed at 32 across experiments. This opens the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 417, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 417, + 506, + 432 + ], + "score": 1.0, + "content": "question of whether the improved performance of the predictron was not just an artifact of having", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 429, + 436, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 436, + 442 + ], + "score": 1.0, + "content": "more parameters. We tested this hypothesis, and the results are shown in Figure 9.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 443, + 505, + 498 + ], + "lines": [ + { + "bbox": [ + 105, + 443, + 497, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 443, + 497, + 455 + ], + "score": 1.0, + "content": "Figure 9 shows that in each setting—on the mazes and pool, and with or without shared cores—", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 453, + 505, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 505, + 466 + ], + "score": 1.0, + "content": "both. The predictrons always performed better than all the deep networks. This includes the 32", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 465, + 504, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 504, + 477 + ], + "score": 1.0, + "content": "node predictron (darkest red) compared to the 512 node deep network (lightest blue), even though", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 475, + 506, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 506, + 489 + ], + "score": 1.0, + "content": "the latter has approximately 4 times as many parameters (1.27M vs 4.85M). This means that the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 487, + 414, + 499 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 414, + 499 + ], + "score": 1.0, + "content": "number of parameters mattered less than whether or not we use a predictron.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 17 + }, + { + "type": "title", + "bbox": [ + 109, + 514, + 286, + 525 + ], + "lines": [ + { + "bbox": [ + 105, + 513, + 288, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 288, + 527 + ], + "score": 1.0, + "content": "E ADDITIONAL DOMAIN DETAILS", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 108, + 536, + 316, + 547 + ], + "lines": [ + { + "bbox": [ + 106, + 535, + 318, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 535, + 318, + 549 + ], + "score": 1.0, + "content": "We now provide some additional details of domains.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "title", + "bbox": [ + 107, + 560, + 156, + 571 + ], + "lines": [ + { + "bbox": [ + 105, + 558, + 159, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 159, + 572 + ], + "score": 1.0, + "content": "E.1 POOL", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 578, + 338, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 578, + 339, + 590 + ], + "spans": [ + { + "bbox": [ + 106, + 578, + 339, + 590 + ], + "score": 1.0, + "content": "To generate sequences in the Pool domain, the initial loca-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 588, + 339, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 339, + 601 + ], + "score": 1.0, + "content": "tions of 4 balls of different colours are sampled at random.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 599, + 339, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 339, + 613 + ], + "score": 1.0, + "content": "The white ball is the only one moving initially. Its velocity", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 611, + 339, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 339, + 623 + ], + "score": 1.0, + "content": "has a norm sampled uniformly between 7 and 14. The ini-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 622, + 340, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 282, + 634 + ], + "score": 1.0, + "content": "tial angle is sampled uniformly in the range", + "type": "text" + }, + { + "bbox": [ + 282, + 622, + 310, + 633 + ], + "score": 0.82, + "content": "( 0 , 2 \\pi )", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 622, + 340, + 634 + ], + "score": 1.0, + "content": ". From", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 632, + 340, + 645 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 340, + 645 + ], + "score": 1.0, + "content": "the initial condition, the Mujoco simulation is run forward", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 644, + 340, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 340, + 656 + ], + "score": 1.0, + "content": "until all balls have stopped moving; sequences that last", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 655, + 339, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 339, + 667 + ], + "score": 1.0, + "content": "more than 151 frames are rejected, and a new one is gen-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 666, + 339, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 339, + 678 + ], + "score": 1.0, + "content": "erated as replacement. Each frame is rendered by Mujoco", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 677, + 339, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 126, + 689 + ], + "score": 1.0, + "content": "as a", + "type": "text" + }, + { + "bbox": [ + 127, + 677, + 164, + 687 + ], + "score": 0.76, + "content": "2 8 0 \\mathbf { x } 2 8 0", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 677, + 339, + 689 + ], + "score": 1.0, + "content": "RGB image, and subsequently downsam-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 687, + 340, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 340, + 700 + ], + "score": 1.0, + "content": "pled through bilinear interpolation to a 28x28 RGB input", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 699, + 339, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 339, + 711 + ], + "score": 1.0, + "content": "(see Figure 10 for an example). Since the 280 signals de-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 709, + 339, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 339, + 722 + ], + "score": 1.0, + "content": "scribed in Section 6.1 as targets for the Pool experiments", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 721, + 339, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 339, + 733 + ], + "score": 1.0, + "content": "have very different levels of sparsity, resulting in values", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 30.5 + }, + { + "type": "image", + "bbox": [ + 381, + 551, + 473, + 643 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 381, + 551, + 473, + 643 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 381, + 551, + 473, + 643 + ], + "spans": [ + { + "bbox": [ + 381, + 551, + 473, + 643 + ], + "score": 0.959, + "type": "image", + "image_path": "5d383c73a965d3d3933c82e67191cd7d3082ff03872892bee902b7940be8a77b.jpg" + } + ] + } + ], + "index": 29.0, + "virtual_lines": [ + { + "bbox": [ + 381, + 551, + 473, + 597.0 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 381, + 597.0, + 473, + 643.0 + ], + "spans": [], + "index": 33 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 347, + 661, + 505, + 694 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 346, + 660, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 346, + 660, + 505, + 673 + ], + "score": 1.0, + "content": "Figure 10: Pool input frame. An ex-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 345, + 671, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 345, + 671, + 393, + 684 + ], + "score": 1.0, + "content": "ample of a", + "type": "text" + }, + { + "bbox": [ + 393, + 672, + 420, + 682 + ], + "score": 0.46, + "content": "2 8 \\mathbf { x } 2 8", + "type": "inline_equation" + }, + { + "bbox": [ + 420, + 671, + 505, + 684 + ], + "score": 1.0, + "content": "RGB input frame in", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 346, + 683, + 416, + 695 + ], + "spans": [ + { + "bbox": [ + 346, + 683, + 416, + 695 + ], + "score": 1.0, + "content": "the pool domain.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40 + } + ], + "index": 34.5 + } + ], + "page_idx": 12, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 301, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 298, + 750, + 312, + 763 + ], + "spans": [ + { + "bbox": [ + 298, + 750, + 312, + 763 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 13, + "width": 14 + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 108, + 27, + 307, + 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" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 122, + 81, + 489, + 270 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 122, + 81, + 489, + 270 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 122, + 81, + 489, + 270 + ], + "spans": [ + { + "bbox": [ + 122, + 81, + 489, + 270 + ], + "score": 0.976, + "type": "image", + "image_path": "93fd02c8270d80a1af3e7ef67faee6943d3152147776544fec0ca60f183fb98d.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 122, + 81, + 489, + 144.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 122, + 144.0, + 489, + 207.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 122, + 207.0, + 489, + 270.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 285, + 505, + 362 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 284, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 295, + 299 + ], + "score": 1.0, + "content": "Figure 9: Comparing depths. Comparing the", + "type": "text" + }, + { + "bbox": [ + 295, + 285, + 328, + 298 + ], + "score": 0.93, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 328, + 284, + 506, + 299 + ], + "score": 1.0, + "content": "-predictron (red) against more conventional", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 296, + 505, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 505, + 309 + ], + "score": 1.0, + "content": "deep networks (blue) for different numbers hidden nodes in the fully connected layers, and therefore", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 306, + 505, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 505, + 321 + ], + "score": 1.0, + "content": "different total numbers of parameters. The deep networks with 32, 128, and 512 nodes respectively", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 319, + 505, + 330 + ], + "spans": [ + { + "bbox": [ + 106, + 319, + 505, + 330 + ], + "score": 1.0, + "content": "have 381,416, 1,275,752, and 4,853,096 parameters in total. The predictrons with 32 and 128 nodes", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 330, + 505, + 342 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 505, + 342 + ], + "score": 1.0, + "content": "respectively have 1,275,752, and 4,853,096 parameters in total. Note that the number of parameters", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 340, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 505, + 353 + ], + "score": 1.0, + "content": "for the 32 and 128 node predictrons are exactly equal to the number of parameters for the 128 and", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 351, + 209, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 209, + 365 + ], + "score": 1.0, + "content": "512 node deep networks.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 385, + 505, + 441 + ], + "lines": [ + { + "bbox": [ + 106, + 384, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 106, + 384, + 505, + 397 + ], + "score": 1.0, + "content": "The deep network with 128 hidden nodes for its values has the exact same number of parameters", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 396, + 505, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 133, + 409 + ], + "score": 1.0, + "content": "as the", + "type": "text" + }, + { + "bbox": [ + 134, + 396, + 166, + 408 + ], + "score": 0.93, + "content": "( r , \\gamma , \\lambda )", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 396, + 505, + 409 + ], + "score": 1.0, + "content": "-predictron with 32 hidden nodes for each of its outputs. Before, the deep network", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 406, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 505, + 420 + ], + "score": 1.0, + "content": "had fewer parameters, because we kept this number fixed at 32 across experiments. This opens the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 417, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 417, + 506, + 432 + ], + "score": 1.0, + "content": "question of whether the improved performance of the predictron was not just an artifact of having", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 429, + 436, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 436, + 442 + ], + "score": 1.0, + "content": "more parameters. We tested this hypothesis, and the results are shown in Figure 9.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 384, + 506, + 442 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 443, + 505, + 498 + ], + "lines": [ + { + "bbox": [ + 105, + 443, + 497, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 443, + 497, + 455 + ], + "score": 1.0, + "content": "Figure 9 shows that in each setting—on the mazes and pool, and with or without shared cores—", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 453, + 505, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 505, + 466 + ], + "score": 1.0, + "content": "both. The predictrons always performed better than all the deep networks. This includes the 32", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 465, + 504, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 504, + 477 + ], + "score": 1.0, + "content": "node predictron (darkest red) compared to the 512 node deep network (lightest blue), even though", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 475, + 506, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 506, + 489 + ], + "score": 1.0, + "content": "the latter has approximately 4 times as many parameters (1.27M vs 4.85M). This means that the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 487, + 414, + 499 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 414, + 499 + ], + "score": 1.0, + "content": "number of parameters mattered less than whether or not we use a predictron.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 443, + 506, + 499 + ] + }, + { + "type": "title", + "bbox": [ + 109, + 514, + 286, + 525 + ], + "lines": [ + { + "bbox": [ + 105, + 513, + 288, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 288, + 527 + ], + "score": 1.0, + "content": "E ADDITIONAL DOMAIN DETAILS", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 108, + 536, + 316, + 547 + ], + "lines": [ + { + "bbox": [ + 106, + 535, + 318, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 535, + 318, + 549 + ], + "score": 1.0, + "content": "We now provide some additional details of domains.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21, + "bbox_fs": [ + 106, + 535, + 318, + 549 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 560, + 156, + 571 + ], + "lines": [ + { + "bbox": [ + 105, + 558, + 159, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 159, + 572 + ], + "score": 1.0, + "content": "E.1 POOL", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 578, + 338, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 578, + 339, + 590 + ], + "spans": [ + { + "bbox": [ + 106, + 578, + 339, + 590 + ], + "score": 1.0, + "content": "To generate sequences in the Pool domain, the initial loca-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 588, + 339, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 339, + 601 + ], + "score": 1.0, + "content": "tions of 4 balls of different colours are sampled at random.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 599, + 339, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 339, + 613 + ], + "score": 1.0, + "content": "The white ball is the only one moving initially. Its velocity", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 611, + 339, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 339, + 623 + ], + "score": 1.0, + "content": "has a norm sampled uniformly between 7 and 14. The ini-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 622, + 340, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 282, + 634 + ], + "score": 1.0, + "content": "tial angle is sampled uniformly in the range", + "type": "text" + }, + { + "bbox": [ + 282, + 622, + 310, + 633 + ], + "score": 0.82, + "content": "( 0 , 2 \\pi )", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 622, + 340, + 634 + ], + "score": 1.0, + "content": ". From", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 632, + 340, + 645 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 340, + 645 + ], + "score": 1.0, + "content": "the initial condition, the Mujoco simulation is run forward", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 644, + 340, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 340, + 656 + ], + "score": 1.0, + "content": "until all balls have stopped moving; sequences that last", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 655, + 339, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 339, + 667 + ], + "score": 1.0, + "content": "more than 151 frames are rejected, and a new one is gen-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 666, + 339, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 339, + 678 + ], + "score": 1.0, + "content": "erated as replacement. Each frame is rendered by Mujoco", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 677, + 339, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 126, + 689 + ], + "score": 1.0, + "content": "as a", + "type": "text" + }, + { + "bbox": [ + 127, + 677, + 164, + 687 + ], + "score": 0.76, + "content": "2 8 0 \\mathbf { x } 2 8 0", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 677, + 339, + 689 + ], + "score": 1.0, + "content": "RGB image, and subsequently downsam-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 687, + 340, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 340, + 700 + ], + "score": 1.0, + "content": "pled through bilinear interpolation to a 28x28 RGB input", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 699, + 339, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 339, + 711 + ], + "score": 1.0, + "content": "(see Figure 10 for an example). Since the 280 signals de-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 709, + 339, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 339, + 722 + ], + "score": 1.0, + "content": "scribed in Section 6.1 as targets for the Pool experiments", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 721, + 339, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 339, + 733 + ], + "score": 1.0, + "content": "have very different levels of sparsity, resulting in values", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "with very different scales, we have normalised the pseudo returns. The normalization procedure", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "consisted in dividing all targets by their standard deviation, as empirically measured across an initial", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 105, + 206, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 206, + 117 + ], + "score": 1.0, + "content": "set of 20,000 sequences.", + "type": "text", + "cross_page": true + } + ], + "index": 2 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 578, + 340, + 733 + ] + }, + { + "type": "image", + "bbox": [ + 381, + 551, + 473, + 643 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 381, + 551, + 473, + 643 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 381, + 551, + 473, + 643 + ], + "spans": [ + { + "bbox": [ + 381, + 551, + 473, + 643 + ], + "score": 0.959, + "type": "image", + "image_path": "5d383c73a965d3d3933c82e67191cd7d3082ff03872892bee902b7940be8a77b.jpg" + } + ] + } + ], + "index": 29.0, + "virtual_lines": [ + { + "bbox": [ + 381, + 551, + 473, + 597.0 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 381, + 597.0, + 473, + 643.0 + ], + "spans": [], + "index": 33 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 347, + 661, + 505, + 694 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 346, + 660, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 346, + 660, + 505, + 673 + ], + "score": 1.0, + "content": "Figure 10: Pool input frame. An ex-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 345, + 671, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 345, + 671, + 393, + 684 + ], + "score": 1.0, + "content": "ample of a", + "type": "text" + }, + { + "bbox": [ + 393, + 672, + 420, + 682 + ], + "score": 0.46, + "content": "2 8 \\mathbf { x } 2 8", + "type": "inline_equation" + }, + { + "bbox": [ + 420, + 671, + 505, + 684 + ], + "score": 1.0, + "content": "RGB input frame in", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 346, + 683, + 416, + 695 + ], + "spans": [ + { + "bbox": [ + 346, + 683, + 416, + 695 + ], + "score": 1.0, + "content": "the pool domain.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40 + } + ], + "index": 34.5 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 504, + 115 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "with very different scales, we have normalised the pseudo returns. The normalization procedure", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "consisted in dividing all targets by their standard deviation, as empirically measured across an initial", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 105, + 206, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 206, + 117 + ], + "score": 1.0, + "content": "set of 20,000 sequences.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "title", + "bbox": [ + 107, + 126, + 207, + 137 + ], + "lines": [ + { + "bbox": [ + 105, + 124, + 207, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 124, + 207, + 139 + ], + "score": 1.0, + "content": "E.2 RANDOM MAZES", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 107, + 144, + 505, + 201 + ], + "lines": [ + { + "bbox": [ + 105, + 142, + 505, + 157 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 505, + 157 + ], + "score": 1.0, + "content": "To generate mazes we first determine, with a stochastic line search, a number of walls so that the top-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 153, + 505, + 168 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 505, + 168 + ], + "score": 1.0, + "content": "left corner is connected to the bottom-right corner (both always forced to be empty) in approximately", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 165, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 106, + 166, + 126, + 176 + ], + "score": 0.85, + "content": "50 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 165, + 505, + 178 + ], + "score": 1.0, + "content": "of the mazes. We then shuffle the walls uniformly randomly. For 20 by 20 mazes this means", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 175, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 126, + 187 + ], + "score": 0.84, + "content": "70 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 175, + 240, + 190 + ], + "score": 1.0, + "content": "of locations are empty and", + "type": "text" + }, + { + "bbox": [ + 240, + 177, + 260, + 187 + ], + "score": 0.85, + "content": "30 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 175, + 505, + 190 + ], + "score": 1.0, + "content": "contain walls. More than a googol different such 20-by-20", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 182, + 236, + 206 + ], + "spans": [ + { + "bbox": [ + 106, + 182, + 169, + 206 + ], + "score": 1.0, + "content": "mazes exist (as", + "type": "text" + }, + { + "bbox": [ + 170, + 187, + 228, + 202 + ], + "score": 0.91, + "content": "\\mathrm { \\binom { 3 9 8 } { 1 2 0 } } > \\mathrm { \\bar { 1 0 } ^ { \\bar { 1 } 0 0 } } ,", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 182, + 236, + 206 + ], + "score": 1.0, + "content": ").", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6 + } + ], + "page_idx": 13, + "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": [ + 300, + 752, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 14 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 504, + 115 + ], + "lines": [], + "index": 1, + "bbox_fs": [ + 106, + 82, + 505, + 117 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 107, + 126, + 207, + 137 + ], + "lines": [ + { + "bbox": [ + 105, + 124, + 207, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 124, + 207, + 139 + ], + "score": 1.0, + "content": "E.2 RANDOM MAZES", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 107, + 144, + 505, + 201 + ], + "lines": [ + { + "bbox": [ + 105, + 142, + 505, + 157 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 505, + 157 + ], + "score": 1.0, + "content": "To generate mazes we first determine, with a stochastic line search, a number of walls so that the top-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 153, + 505, + 168 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 505, + 168 + ], + "score": 1.0, + "content": "left corner is connected to the bottom-right corner (both always forced to be empty) in approximately", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 165, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 106, + 166, + 126, + 176 + ], + "score": 0.85, + "content": "50 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 165, + 505, + 178 + ], + "score": 1.0, + "content": "of the mazes. We then shuffle the walls uniformly randomly. For 20 by 20 mazes this means", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 175, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 126, + 187 + ], + "score": 0.84, + "content": "70 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 175, + 240, + 190 + ], + "score": 1.0, + "content": "of locations are empty and", + "type": "text" + }, + { + "bbox": [ + 240, + 177, + 260, + 187 + ], + "score": 0.85, + "content": "30 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 175, + 505, + 190 + ], + "score": 1.0, + "content": "contain walls. More than a googol different such 20-by-20", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 182, + 236, + 206 + ], + "spans": [ + { + "bbox": [ + 106, + 182, + 169, + 206 + ], + "score": 1.0, + "content": "mazes exist (as", + "type": "text" + }, + { + "bbox": [ + 170, + 187, + 228, + 202 + ], + "score": 0.91, + "content": "\\mathrm { \\binom { 3 9 8 } { 1 2 0 } } > \\mathrm { \\bar { 1 0 } ^ { \\bar { 1 } 0 0 } } ,", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 182, + 236, + 206 + ], + "score": 1.0, + "content": ").", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6, + "bbox_fs": [ + 105, + 142, + 505, + 206 + ] + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file