diff --git "a/parse/train/r154_g-Rb/r154_g-Rb_middle.json" "b/parse/train/r154_g-Rb/r154_g-Rb_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/r154_g-Rb/r154_g-Rb_middle.json" @@ -0,0 +1,34159 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 79, + 435, + 96 + ], + "lines": [ + { + "bbox": [ + 105, + 78, + 438, + 99 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 438, + 99 + ], + "score": 1.0, + "content": "COMPOSABLE PLANNING WITH ATTRIBUTES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 112, + 115, + 244, + 137 + ], + "lines": [ + { + "bbox": [ + 113, + 115, + 201, + 127 + ], + "spans": [ + { + "bbox": [ + 113, + 115, + 201, + 127 + ], + "score": 1.0, + "content": "Anonymous authors", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 111, + 126, + 245, + 138 + ], + "spans": [ + { + "bbox": [ + 111, + 126, + 245, + 138 + ], + "score": 1.0, + "content": "Paper under double-blind review", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1.5 + }, + { + "type": "title", + "bbox": [ + 278, + 167, + 333, + 178 + ], + "lines": [ + { + "bbox": [ + 276, + 166, + 335, + 180 + ], + "spans": [ + { + "bbox": [ + 276, + 166, + 335, + 180 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 143, + 191, + 468, + 345 + ], + "lines": [ + { + "bbox": [ + 141, + 189, + 470, + 206 + ], + "spans": [ + { + "bbox": [ + 141, + 189, + 470, + 206 + ], + "score": 1.0, + "content": "The tasks that an agent will need to solve often aren’t known during training.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 141, + 201, + 469, + 215 + ], + "spans": [ + { + "bbox": [ + 141, + 201, + 469, + 215 + ], + "score": 1.0, + "content": "However, if the agent knows which properties of the environment are important,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 213, + 469, + 226 + ], + "spans": [ + { + "bbox": [ + 141, + 213, + 469, + 226 + ], + "score": 1.0, + "content": "then after learning how its actions affect those properties the agent may be able to", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 224, + 469, + 236 + ], + "spans": [ + { + "bbox": [ + 141, + 224, + 469, + 236 + ], + "score": 1.0, + "content": "use this knowledge to solve complex tasks without training specifically for them.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 235, + 469, + 248 + ], + "spans": [ + { + "bbox": [ + 141, + 235, + 469, + 248 + ], + "score": 1.0, + "content": "Towards this end, we consider a setup in which an environment is augmented", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 246, + 470, + 259 + ], + "spans": [ + { + "bbox": [ + 141, + 246, + 470, + 259 + ], + "score": 1.0, + "content": "with a set of user defined attributes that parameterize the features of interest. We", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 258, + 470, + 269 + ], + "spans": [ + { + "bbox": [ + 141, + 258, + 470, + 269 + ], + "score": 1.0, + "content": "propose a method that learns a policy for transitioning between “nearby” sets of", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 268, + 470, + 281 + ], + "spans": [ + { + "bbox": [ + 141, + 268, + 470, + 281 + ], + "score": 1.0, + "content": "attributes, and maintains a graph of possible transitions. Given a task at test time", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 279, + 469, + 291 + ], + "spans": [ + { + "bbox": [ + 141, + 279, + 469, + 291 + ], + "score": 1.0, + "content": "that can be expressed in terms of a target set of attributes, and a current state,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 290, + 469, + 302 + ], + "spans": [ + { + "bbox": [ + 141, + 290, + 469, + 302 + ], + "score": 1.0, + "content": "our model infers the attributes of the current state and searches over paths through", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 142, + 302, + 470, + 313 + ], + "spans": [ + { + "bbox": [ + 142, + 302, + 470, + 313 + ], + "score": 1.0, + "content": "attribute space to get a high level plan, and then uses its low level policy to execute", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 312, + 470, + 325 + ], + "spans": [ + { + "bbox": [ + 141, + 312, + 470, + 325 + ], + "score": 1.0, + "content": "the plan. We show in grid-world games and 3D block stacking that our model is", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 142, + 324, + 469, + 335 + ], + "spans": [ + { + "bbox": [ + 142, + 324, + 469, + 335 + ], + "score": 1.0, + "content": "able to generalize to longer, more complex tasks at test time even when it only", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 335, + 291, + 346 + ], + "spans": [ + { + "bbox": [ + 141, + 335, + 291, + 346 + ], + "score": 1.0, + "content": "sees short, simple tasks at train time.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 10.5 + }, + { + "type": "title", + "bbox": [ + 108, + 366, + 205, + 379 + ], + "lines": [ + { + "bbox": [ + 105, + 365, + 208, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 365, + 208, + 382 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 391, + 505, + 490 + ], + "lines": [ + { + "bbox": [ + 106, + 391, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 391, + 505, + 403 + ], + "score": 1.0, + "content": "Deep reinforcement learning has demonstrated impressive successes in building agents that can", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "score": 1.0, + "content": "solve difficult tasks, e.g. Mnih et al. (2015); Silver et al. (2016). However, these successes have", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 414, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 106, + 414, + 505, + 425 + ], + "score": 1.0, + "content": "mostly been confined to situations where it is possible to train a large number of times on a single", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 424, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 106, + 424, + 505, + 436 + ], + "score": 1.0, + "content": "known task or distribution of tasks. On the other hand, in some situations, the tasks of interest are not", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 435, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 505, + 447 + ], + "score": 1.0, + "content": "known at training time or are too complex to be completed by uninformed exploration on a sparse", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 445, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 505, + 459 + ], + "score": 1.0, + "content": "set of rewards. In these situations, it may be that the cost of the supervision required to identify the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 457, + 506, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 506, + 470 + ], + "score": 1.0, + "content": "important features of the environment, or to describe the space of possible tasks within it, is not so", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 468, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 105, + 468, + 505, + 480 + ], + "score": 1.0, + "content": "onerous. Recently several papers have taken this approach, for example Reed & de Freitas (2015);", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 479, + 342, + 491 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 342, + 491 + ], + "score": 1.0, + "content": "Andreas et al. (2017); Oh et al. (2017); Denil et al. (2017).", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 496, + 504, + 562 + ], + "lines": [ + { + "bbox": [ + 105, + 495, + 506, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 506, + 508 + ], + "score": 1.0, + "content": "If we expect an agent to be able to solve many different kinds of tasks, the representation of the task", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 506, + 506, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 506, + 520 + ], + "score": 1.0, + "content": "space is particularly important. In this paper, we impose structure on the task space through the use", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 517, + 505, + 531 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 505, + 531 + ], + "score": 1.0, + "content": "of attribute sets, a high-level abstraction of the environment state. The form of these are chosen by", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 528, + 506, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 506, + 541 + ], + "score": 1.0, + "content": "hand to capture task-relevant concepts, allowing both end goals as well as intermediate sub-tasks to", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 540, + 506, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 552 + ], + "score": 1.0, + "content": "be succinctly represented. As in Reed & de Freitas (2015); Andreas et al. (2017); Oh et al. (2017),", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 551, + 309, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 309, + 563 + ], + "score": 1.0, + "content": "we thus trade extra supervision for generalization.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 30.5 + }, + { + "type": "text", + "bbox": [ + 107, + 567, + 505, + 633 + ], + "lines": [ + { + "bbox": [ + 106, + 567, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 505, + 579 + ], + "score": 1.0, + "content": "The attributes yield a natural space in which to plan: instead of searching over possible sequences", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 579, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 505, + 591 + ], + "score": 1.0, + "content": "of actions, we instead search over attribute sets. Once the agent learns how its actions affect the en-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 589, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 505, + 603 + ], + "score": 1.0, + "content": "vironment in terms of its relevant attributes, novel tasks can be solved compositionally by executing", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 600, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 505, + 613 + ], + "score": 1.0, + "content": "a plan consisting of a sequence of transitions between abstract states defined by those attributes. In", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 612, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 106, + 612, + 505, + 623 + ], + "score": 1.0, + "content": "the experiments below, we will show that in various environments, training only on simple tasks,", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 622, + 360, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 360, + 634 + ], + "score": 1.0, + "content": "our agents are able to generalize to novel, more complex tasks.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36.5 + }, + { + "type": "title", + "bbox": [ + 108, + 649, + 164, + 662 + ], + "lines": [ + { + "bbox": [ + 104, + 646, + 167, + 665 + ], + "spans": [ + { + "bbox": [ + 104, + 646, + 167, + 665 + ], + "score": 1.0, + "content": "2 MODEL", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 107, + 675, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 674, + 504, + 687 + ], + "spans": [ + { + "bbox": [ + 106, + 674, + 497, + 687 + ], + "score": 1.0, + "content": "We consider an agent in a Markov environment, i.e. at each time the agent observes the state", + "type": "text" + }, + { + "bbox": [ + 498, + 677, + 504, + 685 + ], + "score": 0.68, + "content": "s", + "type": "inline_equation" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 685, + 504, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 685, + 176, + 698 + ], + "score": 1.0, + "content": "and takes action", + "type": "text" + }, + { + "bbox": [ + 176, + 688, + 182, + 695 + ], + "score": 0.66, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 685, + 364, + 698 + ], + "score": 1.0, + "content": ", which uniquely determines the probability", + "type": "text" + }, + { + "bbox": [ + 364, + 685, + 407, + 698 + ], + "score": 0.93, + "content": "P ( s , a , s ^ { \\prime } )", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 685, + 498, + 698 + ], + "score": 1.0, + "content": "of transitioning from", + "type": "text" + }, + { + "bbox": [ + 498, + 688, + 504, + 695 + ], + "score": 0.47, + "content": "s", + "type": "inline_equation" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 696, + 505, + 709 + ], + "spans": [ + { + "bbox": [ + 105, + 696, + 117, + 709 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 118, + 697, + 126, + 707 + ], + "score": 0.83, + "content": "s ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 126, + 696, + 303, + 709 + ], + "score": 1.0, + "content": ". We augment the environment with a map", + "type": "text" + }, + { + "bbox": [ + 303, + 697, + 360, + 709 + ], + "score": 0.92, + "content": "f : S \\{ \\rho \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 696, + 505, + 709 + ], + "score": 1.0, + "content": "from states to a set of user-defined", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 707, + 506, + 721 + ], + "spans": [ + { + "bbox": [ + 105, + 707, + 146, + 721 + ], + "score": 1.0, + "content": "attributes", + "type": "text" + }, + { + "bbox": [ + 147, + 709, + 153, + 719 + ], + "score": 0.78, + "content": "\\rho", + "type": "inline_equation" + }, + { + "bbox": [ + 154, + 707, + 255, + 721 + ], + "score": 1.0, + "content": ". We assume that either", + "type": "text" + }, + { + "bbox": [ + 256, + 708, + 263, + 719 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 707, + 442, + 721 + ], + "score": 1.0, + "content": "is provided or a small set of hand-labeled", + "type": "text" + }, + { + "bbox": [ + 442, + 708, + 465, + 720 + ], + "score": 0.92, + "content": "( s , \\rho )", + "type": "inline_equation" + }, + { + "bbox": [ + 465, + 707, + 506, + 721 + ], + "score": 1.0, + "content": "pairs are", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 719, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 268, + 733 + ], + "score": 1.0, + "content": "provided in order to learning a mapping", + "type": "text" + }, + { + "bbox": [ + 268, + 719, + 275, + 732 + ], + "score": 0.86, + "content": "\\hat { f }", + "type": "inline_equation" + }, + { + "bbox": [ + 275, + 720, + 506, + 733 + ], + "score": 1.0, + "content": ". Hence, the attributes are human defined and constitute a", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 303, + 752, + 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": [ + 108, + 79, + 435, + 96 + ], + "lines": [ + { + "bbox": [ + 105, + 78, + 438, + 99 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 438, + 99 + ], + "score": 1.0, + "content": "COMPOSABLE PLANNING WITH ATTRIBUTES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 112, + 115, + 244, + 137 + ], + "lines": [ + { + "bbox": [ + 113, + 115, + 201, + 127 + ], + "spans": [ + { + "bbox": [ + 113, + 115, + 201, + 127 + ], + "score": 1.0, + "content": "Anonymous authors", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 111, + 126, + 245, + 138 + ], + "spans": [ + { + "bbox": [ + 111, + 126, + 245, + 138 + ], + "score": 1.0, + "content": "Paper under double-blind review", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1.5, + "bbox_fs": [ + 111, + 115, + 245, + 138 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 167, + 333, + 178 + ], + "lines": [ + { + "bbox": [ + 276, + 166, + 335, + 180 + ], + "spans": [ + { + "bbox": [ + 276, + 166, + 335, + 180 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 143, + 191, + 468, + 345 + ], + "lines": [ + { + "bbox": [ + 141, + 189, + 470, + 206 + ], + "spans": [ + { + "bbox": [ + 141, + 189, + 470, + 206 + ], + "score": 1.0, + "content": "The tasks that an agent will need to solve often aren’t known during training.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 141, + 201, + 469, + 215 + ], + "spans": [ + { + "bbox": [ + 141, + 201, + 469, + 215 + ], + "score": 1.0, + "content": "However, if the agent knows which properties of the environment are important,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 213, + 469, + 226 + ], + "spans": [ + { + "bbox": [ + 141, + 213, + 469, + 226 + ], + "score": 1.0, + "content": "then after learning how its actions affect those properties the agent may be able to", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 224, + 469, + 236 + ], + "spans": [ + { + "bbox": [ + 141, + 224, + 469, + 236 + ], + "score": 1.0, + "content": "use this knowledge to solve complex tasks without training specifically for them.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 235, + 469, + 248 + ], + "spans": [ + { + "bbox": [ + 141, + 235, + 469, + 248 + ], + "score": 1.0, + "content": "Towards this end, we consider a setup in which an environment is augmented", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 246, + 470, + 259 + ], + "spans": [ + { + "bbox": [ + 141, + 246, + 470, + 259 + ], + "score": 1.0, + "content": "with a set of user defined attributes that parameterize the features of interest. We", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 258, + 470, + 269 + ], + "spans": [ + { + "bbox": [ + 141, + 258, + 470, + 269 + ], + "score": 1.0, + "content": "propose a method that learns a policy for transitioning between “nearby” sets of", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 268, + 470, + 281 + ], + "spans": [ + { + "bbox": [ + 141, + 268, + 470, + 281 + ], + "score": 1.0, + "content": "attributes, and maintains a graph of possible transitions. Given a task at test time", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 279, + 469, + 291 + ], + "spans": [ + { + "bbox": [ + 141, + 279, + 469, + 291 + ], + "score": 1.0, + "content": "that can be expressed in terms of a target set of attributes, and a current state,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 290, + 469, + 302 + ], + "spans": [ + { + "bbox": [ + 141, + 290, + 469, + 302 + ], + "score": 1.0, + "content": "our model infers the attributes of the current state and searches over paths through", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 142, + 302, + 470, + 313 + ], + "spans": [ + { + "bbox": [ + 142, + 302, + 470, + 313 + ], + "score": 1.0, + "content": "attribute space to get a high level plan, and then uses its low level policy to execute", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 312, + 470, + 325 + ], + "spans": [ + { + "bbox": [ + 141, + 312, + 470, + 325 + ], + "score": 1.0, + "content": "the plan. We show in grid-world games and 3D block stacking that our model is", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 142, + 324, + 469, + 335 + ], + "spans": [ + { + "bbox": [ + 142, + 324, + 469, + 335 + ], + "score": 1.0, + "content": "able to generalize to longer, more complex tasks at test time even when it only", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 335, + 291, + 346 + ], + "spans": [ + { + "bbox": [ + 141, + 335, + 291, + 346 + ], + "score": 1.0, + "content": "sees short, simple tasks at train time.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 10.5, + "bbox_fs": [ + 141, + 189, + 470, + 346 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 366, + 205, + 379 + ], + "lines": [ + { + "bbox": [ + 105, + 365, + 208, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 365, + 208, + 382 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 391, + 505, + 490 + ], + "lines": [ + { + "bbox": [ + 106, + 391, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 391, + 505, + 403 + ], + "score": 1.0, + "content": "Deep reinforcement learning has demonstrated impressive successes in building agents that can", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "score": 1.0, + "content": "solve difficult tasks, e.g. Mnih et al. (2015); Silver et al. (2016). However, these successes have", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 414, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 106, + 414, + 505, + 425 + ], + "score": 1.0, + "content": "mostly been confined to situations where it is possible to train a large number of times on a single", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 424, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 106, + 424, + 505, + 436 + ], + "score": 1.0, + "content": "known task or distribution of tasks. On the other hand, in some situations, the tasks of interest are not", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 435, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 505, + 447 + ], + "score": 1.0, + "content": "known at training time or are too complex to be completed by uninformed exploration on a sparse", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 445, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 505, + 459 + ], + "score": 1.0, + "content": "set of rewards. In these situations, it may be that the cost of the supervision required to identify the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 457, + 506, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 506, + 470 + ], + "score": 1.0, + "content": "important features of the environment, or to describe the space of possible tasks within it, is not so", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 468, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 105, + 468, + 505, + 480 + ], + "score": 1.0, + "content": "onerous. Recently several papers have taken this approach, for example Reed & de Freitas (2015);", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 479, + 342, + 491 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 342, + 491 + ], + "score": 1.0, + "content": "Andreas et al. (2017); Oh et al. (2017); Denil et al. (2017).", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 391, + 506, + 491 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 496, + 504, + 562 + ], + "lines": [ + { + "bbox": [ + 105, + 495, + 506, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 506, + 508 + ], + "score": 1.0, + "content": "If we expect an agent to be able to solve many different kinds of tasks, the representation of the task", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 506, + 506, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 506, + 520 + ], + "score": 1.0, + "content": "space is particularly important. In this paper, we impose structure on the task space through the use", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 517, + 505, + 531 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 505, + 531 + ], + "score": 1.0, + "content": "of attribute sets, a high-level abstraction of the environment state. The form of these are chosen by", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 528, + 506, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 506, + 541 + ], + "score": 1.0, + "content": "hand to capture task-relevant concepts, allowing both end goals as well as intermediate sub-tasks to", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 540, + 506, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 552 + ], + "score": 1.0, + "content": "be succinctly represented. As in Reed & de Freitas (2015); Andreas et al. (2017); Oh et al. (2017),", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 551, + 309, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 309, + 563 + ], + "score": 1.0, + "content": "we thus trade extra supervision for generalization.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 495, + 506, + 563 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 567, + 505, + 633 + ], + "lines": [ + { + "bbox": [ + 106, + 567, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 505, + 579 + ], + "score": 1.0, + "content": "The attributes yield a natural space in which to plan: instead of searching over possible sequences", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 579, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 505, + 591 + ], + "score": 1.0, + "content": "of actions, we instead search over attribute sets. Once the agent learns how its actions affect the en-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 589, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 505, + 603 + ], + "score": 1.0, + "content": "vironment in terms of its relevant attributes, novel tasks can be solved compositionally by executing", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 600, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 505, + 613 + ], + "score": 1.0, + "content": "a plan consisting of a sequence of transitions between abstract states defined by those attributes. In", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 612, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 106, + 612, + 505, + 623 + ], + "score": 1.0, + "content": "the experiments below, we will show that in various environments, training only on simple tasks,", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 622, + 360, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 360, + 634 + ], + "score": 1.0, + "content": "our agents are able to generalize to novel, more complex tasks.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 567, + 505, + 634 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 649, + 164, + 662 + ], + "lines": [ + { + "bbox": [ + 104, + 646, + 167, + 665 + ], + "spans": [ + { + "bbox": [ + 104, + 646, + 167, + 665 + ], + "score": 1.0, + "content": "2 MODEL", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 107, + 675, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 674, + 504, + 687 + ], + "spans": [ + { + "bbox": [ + 106, + 674, + 497, + 687 + ], + "score": 1.0, + "content": "We consider an agent in a Markov environment, i.e. at each time the agent observes the state", + "type": "text" + }, + { + "bbox": [ + 498, + 677, + 504, + 685 + ], + "score": 0.68, + "content": "s", + "type": "inline_equation" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 685, + 504, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 685, + 176, + 698 + ], + "score": 1.0, + "content": "and takes action", + "type": "text" + }, + { + "bbox": [ + 176, + 688, + 182, + 695 + ], + "score": 0.66, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 685, + 364, + 698 + ], + "score": 1.0, + "content": ", which uniquely determines the probability", + "type": "text" + }, + { + "bbox": [ + 364, + 685, + 407, + 698 + ], + "score": 0.93, + "content": "P ( s , a , s ^ { \\prime } )", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 685, + 498, + 698 + ], + "score": 1.0, + "content": "of transitioning from", + "type": "text" + }, + { + "bbox": [ + 498, + 688, + 504, + 695 + ], + "score": 0.47, + "content": "s", + "type": "inline_equation" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 696, + 505, + 709 + ], + "spans": [ + { + "bbox": [ + 105, + 696, + 117, + 709 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 118, + 697, + 126, + 707 + ], + "score": 0.83, + "content": "s ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 126, + 696, + 303, + 709 + ], + "score": 1.0, + "content": ". We augment the environment with a map", + "type": "text" + }, + { + "bbox": [ + 303, + 697, + 360, + 709 + ], + "score": 0.92, + "content": "f : S \\{ \\rho \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 696, + 505, + 709 + ], + "score": 1.0, + "content": "from states to a set of user-defined", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 707, + 506, + 721 + ], + "spans": [ + { + "bbox": [ + 105, + 707, + 146, + 721 + ], + "score": 1.0, + "content": "attributes", + "type": "text" + }, + { + "bbox": [ + 147, + 709, + 153, + 719 + ], + "score": 0.78, + "content": "\\rho", + "type": "inline_equation" + }, + { + "bbox": [ + 154, + 707, + 255, + 721 + ], + "score": 1.0, + "content": ". We assume that either", + "type": "text" + }, + { + "bbox": [ + 256, + 708, + 263, + 719 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 707, + 442, + 721 + ], + "score": 1.0, + "content": "is provided or a small set of hand-labeled", + "type": "text" + }, + { + "bbox": [ + 442, + 708, + 465, + 720 + ], + "score": 0.92, + "content": "( s , \\rho )", + "type": "inline_equation" + }, + { + "bbox": [ + 465, + 707, + 506, + 721 + ], + "score": 1.0, + "content": "pairs are", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 719, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 268, + 733 + ], + "score": 1.0, + "content": "provided in order to learning a mapping", + "type": "text" + }, + { + "bbox": [ + 268, + 719, + 275, + 732 + ], + "score": 0.86, + "content": "\\hat { f }", + "type": "inline_equation" + }, + { + "bbox": [ + 275, + 720, + 506, + 733 + ], + "score": 1.0, + "content": ". Hence, the attributes are human defined and constitute a", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 234, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 106, + 234, + 505, + 246 + ], + "score": 1.0, + "content": "form of supervision. Here we consider attributes that are sets of binary vectors. These user-specified", + "type": "text", + "cross_page": true + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 244, + 395, + 258 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 395, + 258 + ], + "score": 1.0, + "content": "attributes parameterize the set of goals that can be specified at test time.", + "type": "text", + "cross_page": true + } + ], + "index": 23 + } + ], + "index": 43, + "bbox_fs": [ + 105, + 674, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 107, + 91, + 265, + 212 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 91, + 265, + 212 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 91, + 265, + 212 + ], + "spans": [ + { + "bbox": [ + 107, + 91, + 265, + 212 + ], + "score": 0.968, + "type": "image", + "image_path": "70e696fa0b3d09f6e36b8473581c706861e235d4eeb625aa215f50810ec0ec31.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 107, + 91, + 265, + 104.44444444444444 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 107, + 104.44444444444444, + 265, + 117.88888888888889 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 107, + 117.88888888888889, + 265, + 131.33333333333334 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 107, + 131.33333333333334, + 265, + 144.7777777777778 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 107, + 144.7777777777778, + 265, + 158.22222222222226 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 107, + 158.22222222222226, + 265, + 171.6666666666667 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 107, + 171.6666666666667, + 265, + 185.11111111111117 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 107, + 185.11111111111117, + 265, + 198.55555555555563 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 107, + 198.55555555555563, + 265, + 212.00000000000009 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 276, + 80, + 504, + 211 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 275, + 81, + 505, + 93 + ], + "spans": [ + { + "bbox": [ + 275, + 81, + 505, + 93 + ], + "score": 1.0, + "content": "Figure 1: Solving complex tasks by planning in attribute", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 275, + 91, + 505, + 103 + ], + "spans": [ + { + "bbox": [ + 275, + 91, + 505, + 103 + ], + "score": 1.0, + "content": "space. Each state is mapped to a set of binary attributes (or-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 275, + 101, + 506, + 113 + ], + "spans": [ + { + "bbox": [ + 275, + 101, + 506, + 113 + ], + "score": 1.0, + "content": "ange/purple dots). Our semi-parametric model comprises a", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 275, + 111, + 505, + 122 + ], + "spans": [ + { + "bbox": [ + 275, + 111, + 505, + 122 + ], + "score": 1.0, + "content": "graph over sets of attributes (e.g. “there is a blue block left", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 275, + 120, + 505, + 132 + ], + "spans": [ + { + "bbox": [ + 275, + 120, + 505, + 132 + ], + "score": 1.0, + "content": "of the red block”), with edge weightings according to the prob-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 275, + 131, + 505, + 141 + ], + "spans": [ + { + "bbox": [ + 275, + 131, + 505, + 141 + ], + "score": 1.0, + "content": "ability that a parametric policy network is able to transition be-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 276, + 141, + 505, + 152 + ], + "spans": [ + { + "bbox": [ + 276, + 141, + 505, + 152 + ], + "score": 1.0, + "content": "tween adjacent pairs. The attributes themselves are manually", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 275, + 151, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 275, + 151, + 505, + 162 + ], + "score": 1.0, + "content": "specified, but inferred from the observation through a neural", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 275, + 160, + 505, + 173 + ], + "spans": [ + { + "bbox": [ + 275, + 160, + 505, + 173 + ], + "score": 1.0, + "content": "network; and the graph structure and policy are learned during", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 275, + 171, + 505, + 182 + ], + "spans": [ + { + "bbox": [ + 275, + 171, + 505, + 182 + ], + "score": 1.0, + "content": "training via random exploration of the environment. Given a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 275, + 181, + 505, + 192 + ], + "spans": [ + { + "bbox": [ + 275, + 181, + 505, + 192 + ], + "score": 1.0, + "content": "goal attribute set (green), we use the graph to find the short-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 275, + 190, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 275, + 190, + 505, + 203 + ], + "score": 1.0, + "content": "est path (red) to it in attribute space. The policy network then", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 276, + 201, + 451, + 212 + ], + "spans": [ + { + "bbox": [ + 276, + 201, + 451, + 212 + ], + "score": 1.0, + "content": "executes the actions at each stage (gold arrows).", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 15 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 107, + 234, + 505, + 256 + ], + "lines": [ + { + "bbox": [ + 106, + 234, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 106, + 234, + 505, + 246 + ], + "score": 1.0, + "content": "form of supervision. Here we consider attributes that are sets of binary vectors. These user-specified", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 244, + 395, + 258 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 395, + 258 + ], + "score": 1.0, + "content": "attributes parameterize the set of goals that can be specified at test time.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 107, + 262, + 213, + 273 + ], + "lines": [ + { + "bbox": [ + 106, + 260, + 215, + 275 + ], + "spans": [ + { + "bbox": [ + 106, + 260, + 215, + 275 + ], + "score": 1.0, + "content": "The model has three parts:", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 129, + 284, + 505, + 362 + ], + "lines": [ + { + "bbox": [ + 129, + 282, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 129, + 282, + 298, + 298 + ], + "score": 1.0, + "content": "1. a neural-net based attribute detector", + "type": "text" + }, + { + "bbox": [ + 298, + 283, + 306, + 296 + ], + "score": 0.86, + "content": "\\hat { f }", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 282, + 387, + 298 + ], + "score": 1.0, + "content": ", which maps states", + "type": "text" + }, + { + "bbox": [ + 387, + 288, + 393, + 295 + ], + "score": 0.64, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 282, + 479, + 298 + ], + "score": 1.0, + "content": "to a set of attributes", + "type": "text" + }, + { + "bbox": [ + 479, + 287, + 486, + 297 + ], + "score": 0.81, + "content": "\\rho", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 282, + 505, + 298 + ], + "score": 1.0, + "content": ", i.e.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 142, + 296, + 185, + 309 + ], + "spans": [ + { + "bbox": [ + 142, + 296, + 180, + 308 + ], + "score": 0.92, + "content": "\\rho = f ( s )", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 296, + 185, + 309 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 129, + 311, + 505, + 325 + ], + "spans": [ + { + "bbox": [ + 129, + 311, + 250, + 325 + ], + "score": 1.0, + "content": "2. a neural net-based policy", + "type": "text" + }, + { + "bbox": [ + 250, + 312, + 284, + 324 + ], + "score": 0.93, + "content": "\\pi ( s , \\rho _ { g } )", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 311, + 479, + 325 + ], + "score": 1.0, + "content": "which takes a pair of inputs: the current state", + "type": "text" + }, + { + "bbox": [ + 480, + 315, + 486, + 322 + ], + "score": 0.77, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 311, + 505, + 325 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 141, + 323, + 421, + 335 + ], + "spans": [ + { + "bbox": [ + 141, + 323, + 247, + 335 + ], + "score": 1.0, + "content": "attributes of the goal state", + "type": "text" + }, + { + "bbox": [ + 248, + 325, + 258, + 335 + ], + "score": 0.86, + "content": "\\rho _ { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 323, + 421, + 335 + ], + "score": 1.0, + "content": ". Its output is a distribution over actions.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 128, + 338, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 128, + 338, + 263, + 353 + ], + "score": 1.0, + "content": "3. a tabular transition function", + "type": "text" + }, + { + "bbox": [ + 263, + 339, + 303, + 351 + ], + "score": 0.93, + "content": "c _ { \\pi } ( \\rho _ { i } , \\rho _ { j } )", + "type": "inline_equation" + }, + { + "bbox": [ + 304, + 338, + 422, + 353 + ], + "score": 1.0, + "content": "that scores the possibility of", + "type": "text" + }, + { + "bbox": [ + 422, + 339, + 463, + 352 + ], + "score": 0.93, + "content": "\\pi ( s _ { \\rho _ { i } } , \\rho _ { j } )", + "type": "inline_equation" + }, + { + "bbox": [ + 463, + 338, + 505, + 353 + ], + "score": 1.0, + "content": "transiting", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 141, + 349, + 358, + 363 + ], + "spans": [ + { + "bbox": [ + 141, + 349, + 215, + 363 + ], + "score": 1.0, + "content": "successfully from", + "type": "text" + }, + { + "bbox": [ + 215, + 352, + 225, + 362 + ], + "score": 0.83, + "content": "\\rho _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 349, + 236, + 363 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 236, + 352, + 247, + 362 + ], + "score": 0.86, + "content": "\\rho _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 247, + 349, + 358, + 363 + ], + "score": 1.0, + "content": "in a small number of steps.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 107, + 371, + 505, + 416 + ], + "lines": [ + { + "bbox": [ + 106, + 372, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 106, + 372, + 473, + 384 + ], + "score": 1.0, + "content": "The transition table keeps track of the transitions seen in training, enabling a transition graph", + "type": "text" + }, + { + "bbox": [ + 474, + 372, + 482, + 382 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 372, + 505, + 384 + ], + "score": 1.0, + "content": "to be", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 383, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 505, + 394 + ], + "score": 1.0, + "content": "constructed that connects distant pairs of attributes. This high-level attribute graph is then searched", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 393, + 506, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 506, + 407 + ], + "score": 1.0, + "content": "at test time to find a path to the goal, with the policy network performing the low-level actions to", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 405, + 260, + 416 + ], + "spans": [ + { + "bbox": [ + 106, + 405, + 260, + 416 + ], + "score": 1.0, + "content": "transition between adjacent attributes.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 107, + 421, + 505, + 500 + ], + "lines": [ + { + "bbox": [ + 105, + 420, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 420, + 505, + 434 + ], + "score": 1.0, + "content": "Since our model uses attributes for planning, we desire a property that we will call “ignorability”", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 433, + 505, + 445 + ], + "spans": [ + { + "bbox": [ + 106, + 433, + 362, + 445 + ], + "score": 1.0, + "content": "which says that the probability of being able to transition from", + "type": "text" + }, + { + "bbox": [ + 362, + 434, + 371, + 444 + ], + "score": 0.84, + "content": "\\rho _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 433, + 383, + 445 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 384, + 434, + 394, + 444 + ], + "score": 0.84, + "content": "\\rho _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 394, + 433, + 505, + 445 + ], + "score": 1.0, + "content": "should only depend on the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 444, + 506, + 458 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 146, + 458 + ], + "score": 1.0, + "content": "attributes", + "type": "text" + }, + { + "bbox": [ + 147, + 447, + 156, + 456 + ], + "score": 0.84, + "content": "\\rho _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 444, + 263, + 458 + ], + "score": 1.0, + "content": ", not the exact state; i.e.", + "type": "text" + }, + { + "bbox": [ + 263, + 444, + 462, + 457 + ], + "score": 0.86, + "content": "P _ { \\pi } ( f ( s _ { t ^ { \\prime } } ) = \\rho _ { j } | f ( s _ { t } ) ) = P _ { \\pi } ( f ( s _ { t ^ { \\prime } } ) = \\rho _ { j } | s _ { t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 444, + 506, + 458 + ], + "score": 1.0, + "content": "1. To the", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 455, + 506, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 506, + 468 + ], + "score": 1.0, + "content": "extent that this condition is violated, then transitions are aliased, and a planned transition may not", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 466, + 506, + 479 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 316, + 479 + ], + "score": 1.0, + "content": "be achievable by the policy from the particular state", + "type": "text" + }, + { + "bbox": [ + 317, + 469, + 323, + 477 + ], + "score": 0.71, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 466, + 506, + 479 + ], + "score": 1.0, + "content": "even though it’s achievable from other states", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 478, + 505, + 490 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 505, + 490 + ], + "score": 1.0, + "content": "with the same properties, causing the model to fail to achieve its goal. Note that in the experiments", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 487, + 263, + 501 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 263, + 501 + ], + "score": 1.0, + "content": "in 4.2, there will be nontrivial aliasing.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 38 + }, + { + "type": "title", + "bbox": [ + 108, + 514, + 209, + 525 + ], + "lines": [ + { + "bbox": [ + 105, + 513, + 210, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 210, + 527 + ], + "score": 1.0, + "content": "2.1 MODEL TRAINING", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 42 + }, + { + "type": "title", + "bbox": [ + 108, + 534, + 246, + 547 + ], + "lines": [ + { + "bbox": [ + 105, + 533, + 246, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 238, + 549 + ], + "score": 1.0, + "content": "2.1.1 ATTRIBUTE DETECTOR", + "type": "text" + }, + { + "bbox": [ + 238, + 534, + 246, + 547 + ], + "score": 0.78, + "content": "\\hat { f }", + "type": "inline_equation" + } + ], + "index": 43 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 107, + 556, + 505, + 601 + ], + "lines": [ + { + "bbox": [ + 105, + 555, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 373, + 569 + ], + "score": 1.0, + "content": "The first step of training consists of fitting the attribute detectors", + "type": "text" + }, + { + "bbox": [ + 374, + 555, + 381, + 568 + ], + "score": 0.88, + "content": "\\hat { f }", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 556, + 446, + 569 + ], + "score": 1.0, + "content": "that map states", + "type": "text" + }, + { + "bbox": [ + 447, + 559, + 453, + 567 + ], + "score": 0.73, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 556, + 505, + 569 + ], + "score": 1.0, + "content": "to attributes", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 107, + 568, + 505, + 580 + ], + "spans": [ + { + "bbox": [ + 107, + 570, + 113, + 579 + ], + "score": 0.71, + "content": "\\rho", + "type": "inline_equation" + }, + { + "bbox": [ + 113, + 568, + 505, + 580 + ], + "score": 1.0, + "content": ". As mentioned above, we assume that there is a set of labeled (state, attribute) examples we can", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 579, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 505, + 591 + ], + "score": 1.0, + "content": "use for fitting this part of the model. Note that these examples are the only supervision given to the", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 590, + 280, + 602 + ], + "spans": [ + { + "bbox": [ + 105, + 590, + 280, + 602 + ], + "score": 1.0, + "content": "model during the entire training procedure.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 45.5 + }, + { + "type": "title", + "bbox": [ + 107, + 615, + 322, + 626 + ], + "lines": [ + { + "bbox": [ + 106, + 614, + 322, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 614, + 283, + 628 + ], + "score": 1.0, + "content": "2.1.2 ATTRIBUTE TRANSITION MODELS", + "type": "text" + }, + { + "bbox": [ + 284, + 618, + 290, + 625 + ], + "score": 0.37, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 614, + 312, + 628 + ], + "score": 1.0, + "content": "AND", + "type": "text" + }, + { + "bbox": [ + 312, + 617, + 322, + 626 + ], + "score": 0.69, + "content": "c _ { \\pi }", + "type": "inline_equation" + } + ], + "index": 48 + } + ], + "index": 48 + }, + { + "type": "text", + "bbox": [ + 107, + 634, + 505, + 701 + ], + "lines": [ + { + "bbox": [ + 106, + 635, + 505, + 646 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 160, + 646 + ], + "score": 1.0, + "content": "To construct", + "type": "text" + }, + { + "bbox": [ + 160, + 637, + 166, + 645 + ], + "score": 0.62, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 635, + 505, + 646 + ], + "score": 1.0, + "content": ", the agent samples transitions from the environment, finding the sets of attributes", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "score": 1.0, + "content": "which actually occur in the environment (from the potentially large number of all possible attributes).", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 656, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 656, + 426, + 669 + ], + "score": 1.0, + "content": "In the experiments below, we place the agent in a state at random with attributes", + "type": "text" + }, + { + "bbox": [ + 426, + 658, + 435, + 668 + ], + "score": 0.84, + "content": "\\rho _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 436, + 656, + 506, + 669 + ], + "score": 1.0, + "content": ". It will then take", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 667, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 472, + 680 + ], + "score": 1.0, + "content": "a random action, or short sequence of actions. These lead to a new state with attributes", + "type": "text" + }, + { + "bbox": [ + 472, + 669, + 483, + 680 + ], + "score": 0.85, + "content": "\\rho _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 667, + 506, + 680 + ], + "score": 1.0, + "content": ", and", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 107, + 678, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 107, + 678, + 142, + 690 + ], + "score": 0.92, + "content": "c ( \\rho _ { i } , \\rho _ { j } )", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 678, + 505, + 691 + ], + "score": 1.0, + "content": "is incremented. This is repeated many times, building up statistics on possible transitions", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 689, + 505, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 391, + 702 + ], + "score": 1.0, + "content": "within attribute space. The resulting table represents a transition graph", + "type": "text" + }, + { + "bbox": [ + 392, + 690, + 401, + 699 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 689, + 505, + 702 + ], + "score": 1.0, + "content": "with vertices given by all", + "type": "text" + } + ], + "index": 54 + } + ], + "index": 51.5 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 711, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 118, + 709, + 505, + 724 + ], + "spans": [ + { + "bbox": [ + 118, + 709, + 389, + 724 + ], + "score": 1.0, + "content": "1Note that the particular sequence of actions that effects the transition from", + "type": "text" + }, + { + "bbox": [ + 389, + 713, + 398, + 722 + ], + "score": 0.83, + "content": "\\rho _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 398, + 709, + 408, + 724 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 408, + 713, + 417, + 722 + ], + "score": 0.85, + "content": "\\rho _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 709, + 505, + 724 + ], + "score": 1.0, + "content": "may still be conditional", + "type": "text" + } + ] + }, + { + "bbox": [ + 105, + 721, + 153, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 153, + 732 + ], + "score": 1.0, + "content": "on the state.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "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": "image", + "bbox": [ + 107, + 91, + 265, + 212 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 91, + 265, + 212 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 91, + 265, + 212 + ], + "spans": [ + { + "bbox": [ + 107, + 91, + 265, + 212 + ], + "score": 0.968, + "type": "image", + "image_path": "70e696fa0b3d09f6e36b8473581c706861e235d4eeb625aa215f50810ec0ec31.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 107, + 91, + 265, + 104.44444444444444 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 107, + 104.44444444444444, + 265, + 117.88888888888889 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 107, + 117.88888888888889, + 265, + 131.33333333333334 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 107, + 131.33333333333334, + 265, + 144.7777777777778 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 107, + 144.7777777777778, + 265, + 158.22222222222226 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 107, + 158.22222222222226, + 265, + 171.6666666666667 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 107, + 171.6666666666667, + 265, + 185.11111111111117 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 107, + 185.11111111111117, + 265, + 198.55555555555563 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 107, + 198.55555555555563, + 265, + 212.00000000000009 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 276, + 80, + 504, + 211 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 275, + 81, + 505, + 93 + ], + "spans": [ + { + "bbox": [ + 275, + 81, + 505, + 93 + ], + "score": 1.0, + "content": "Figure 1: Solving complex tasks by planning in attribute", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 275, + 91, + 505, + 103 + ], + "spans": [ + { + "bbox": [ + 275, + 91, + 505, + 103 + ], + "score": 1.0, + "content": "space. Each state is mapped to a set of binary attributes (or-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 275, + 101, + 506, + 113 + ], + "spans": [ + { + "bbox": [ + 275, + 101, + 506, + 113 + ], + "score": 1.0, + "content": "ange/purple dots). Our semi-parametric model comprises a", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 275, + 111, + 505, + 122 + ], + "spans": [ + { + "bbox": [ + 275, + 111, + 505, + 122 + ], + "score": 1.0, + "content": "graph over sets of attributes (e.g. “there is a blue block left", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 275, + 120, + 505, + 132 + ], + "spans": [ + { + "bbox": [ + 275, + 120, + 505, + 132 + ], + "score": 1.0, + "content": "of the red block”), with edge weightings according to the prob-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 275, + 131, + 505, + 141 + ], + "spans": [ + { + "bbox": [ + 275, + 131, + 505, + 141 + ], + "score": 1.0, + "content": "ability that a parametric policy network is able to transition be-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 276, + 141, + 505, + 152 + ], + "spans": [ + { + "bbox": [ + 276, + 141, + 505, + 152 + ], + "score": 1.0, + "content": "tween adjacent pairs. The attributes themselves are manually", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 275, + 151, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 275, + 151, + 505, + 162 + ], + "score": 1.0, + "content": "specified, but inferred from the observation through a neural", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 275, + 160, + 505, + 173 + ], + "spans": [ + { + "bbox": [ + 275, + 160, + 505, + 173 + ], + "score": 1.0, + "content": "network; and the graph structure and policy are learned during", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 275, + 171, + 505, + 182 + ], + "spans": [ + { + "bbox": [ + 275, + 171, + 505, + 182 + ], + "score": 1.0, + "content": "training via random exploration of the environment. Given a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 275, + 181, + 505, + 192 + ], + "spans": [ + { + "bbox": [ + 275, + 181, + 505, + 192 + ], + "score": 1.0, + "content": "goal attribute set (green), we use the graph to find the short-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 275, + 190, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 275, + 190, + 505, + 203 + ], + "score": 1.0, + "content": "est path (red) to it in attribute space. The policy network then", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 276, + 201, + 451, + 212 + ], + "spans": [ + { + "bbox": [ + 276, + 201, + 451, + 212 + ], + "score": 1.0, + "content": "executes the actions at each stage (gold arrows).", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 15 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 107, + 234, + 505, + 256 + ], + "lines": [], + "index": 22.5, + "bbox_fs": [ + 105, + 234, + 505, + 258 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 262, + 213, + 273 + ], + "lines": [ + { + "bbox": [ + 106, + 260, + 215, + 275 + ], + "spans": [ + { + "bbox": [ + 106, + 260, + 215, + 275 + ], + "score": 1.0, + "content": "The model has three parts:", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24, + "bbox_fs": [ + 106, + 260, + 215, + 275 + ] + }, + { + "type": "list", + "bbox": [ + 129, + 284, + 505, + 362 + ], + "lines": [ + { + "bbox": [ + 129, + 282, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 129, + 282, + 298, + 298 + ], + "score": 1.0, + "content": "1. a neural-net based attribute detector", + "type": "text" + }, + { + "bbox": [ + 298, + 283, + 306, + 296 + ], + "score": 0.86, + "content": "\\hat { f }", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 282, + 387, + 298 + ], + "score": 1.0, + "content": ", which maps states", + "type": "text" + }, + { + "bbox": [ + 387, + 288, + 393, + 295 + ], + "score": 0.64, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 282, + 479, + 298 + ], + "score": 1.0, + "content": "to a set of attributes", + "type": "text" + }, + { + "bbox": [ + 479, + 287, + 486, + 297 + ], + "score": 0.81, + "content": "\\rho", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 282, + 505, + 298 + ], + "score": 1.0, + "content": ", i.e.", + "type": "text" + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 142, + 296, + 185, + 309 + ], + "spans": [ + { + "bbox": [ + 142, + 296, + 180, + 308 + ], + "score": 0.92, + "content": "\\rho = f ( s )", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 296, + 185, + 309 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 26, + "is_list_end_line": true + }, + { + "bbox": [ + 129, + 311, + 505, + 325 + ], + "spans": [ + { + "bbox": [ + 129, + 311, + 250, + 325 + ], + "score": 1.0, + "content": "2. a neural net-based policy", + "type": "text" + }, + { + "bbox": [ + 250, + 312, + 284, + 324 + ], + "score": 0.93, + "content": "\\pi ( s , \\rho _ { g } )", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 311, + 479, + 325 + ], + "score": 1.0, + "content": "which takes a pair of inputs: the current state", + "type": "text" + }, + { + "bbox": [ + 480, + 315, + 486, + 322 + ], + "score": 0.77, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 311, + 505, + 325 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 323, + 421, + 335 + ], + "spans": [ + { + "bbox": [ + 141, + 323, + 247, + 335 + ], + "score": 1.0, + "content": "attributes of the goal state", + "type": "text" + }, + { + "bbox": [ + 248, + 325, + 258, + 335 + ], + "score": 0.86, + "content": "\\rho _ { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 323, + 421, + 335 + ], + "score": 1.0, + "content": ". Its output is a distribution over actions.", + "type": "text" + } + ], + "index": 28, + "is_list_end_line": true + }, + { + "bbox": [ + 128, + 338, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 128, + 338, + 263, + 353 + ], + "score": 1.0, + "content": "3. a tabular transition function", + "type": "text" + }, + { + "bbox": [ + 263, + 339, + 303, + 351 + ], + "score": 0.93, + "content": "c _ { \\pi } ( \\rho _ { i } , \\rho _ { j } )", + "type": "inline_equation" + }, + { + "bbox": [ + 304, + 338, + 422, + 353 + ], + "score": 1.0, + "content": "that scores the possibility of", + "type": "text" + }, + { + "bbox": [ + 422, + 339, + 463, + 352 + ], + "score": 0.93, + "content": "\\pi ( s _ { \\rho _ { i } } , \\rho _ { j } )", + "type": "inline_equation" + }, + { + "bbox": [ + 463, + 338, + 505, + 353 + ], + "score": 1.0, + "content": "transiting", + "type": "text" + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 349, + 358, + 363 + ], + "spans": [ + { + "bbox": [ + 141, + 349, + 215, + 363 + ], + "score": 1.0, + "content": "successfully from", + "type": "text" + }, + { + "bbox": [ + 215, + 352, + 225, + 362 + ], + "score": 0.83, + "content": "\\rho _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 349, + 236, + 363 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 236, + 352, + 247, + 362 + ], + "score": 0.86, + "content": "\\rho _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 247, + 349, + 358, + 363 + ], + "score": 1.0, + "content": "in a small number of steps.", + "type": "text" + } + ], + "index": 30, + "is_list_end_line": true + } + ], + "index": 27.5, + "bbox_fs": [ + 128, + 282, + 505, + 363 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 371, + 505, + 416 + ], + "lines": [ + { + "bbox": [ + 106, + 372, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 106, + 372, + 473, + 384 + ], + "score": 1.0, + "content": "The transition table keeps track of the transitions seen in training, enabling a transition graph", + "type": "text" + }, + { + "bbox": [ + 474, + 372, + 482, + 382 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 372, + 505, + 384 + ], + "score": 1.0, + "content": "to be", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 383, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 505, + 394 + ], + "score": 1.0, + "content": "constructed that connects distant pairs of attributes. This high-level attribute graph is then searched", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 393, + 506, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 506, + 407 + ], + "score": 1.0, + "content": "at test time to find a path to the goal, with the policy network performing the low-level actions to", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 405, + 260, + 416 + ], + "spans": [ + { + "bbox": [ + 106, + 405, + 260, + 416 + ], + "score": 1.0, + "content": "transition between adjacent attributes.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 372, + 506, + 416 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 421, + 505, + 500 + ], + "lines": [ + { + "bbox": [ + 105, + 420, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 420, + 505, + 434 + ], + "score": 1.0, + "content": "Since our model uses attributes for planning, we desire a property that we will call “ignorability”", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 433, + 505, + 445 + ], + "spans": [ + { + "bbox": [ + 106, + 433, + 362, + 445 + ], + "score": 1.0, + "content": "which says that the probability of being able to transition from", + "type": "text" + }, + { + "bbox": [ + 362, + 434, + 371, + 444 + ], + "score": 0.84, + "content": "\\rho _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 433, + 383, + 445 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 384, + 434, + 394, + 444 + ], + "score": 0.84, + "content": "\\rho _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 394, + 433, + 505, + 445 + ], + "score": 1.0, + "content": "should only depend on the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 444, + 506, + 458 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 146, + 458 + ], + "score": 1.0, + "content": "attributes", + "type": "text" + }, + { + "bbox": [ + 147, + 447, + 156, + 456 + ], + "score": 0.84, + "content": "\\rho _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 444, + 263, + 458 + ], + "score": 1.0, + "content": ", not the exact state; i.e.", + "type": "text" + }, + { + "bbox": [ + 263, + 444, + 462, + 457 + ], + "score": 0.86, + "content": "P _ { \\pi } ( f ( s _ { t ^ { \\prime } } ) = \\rho _ { j } | f ( s _ { t } ) ) = P _ { \\pi } ( f ( s _ { t ^ { \\prime } } ) = \\rho _ { j } | s _ { t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 444, + 506, + 458 + ], + "score": 1.0, + "content": "1. To the", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 455, + 506, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 506, + 468 + ], + "score": 1.0, + "content": "extent that this condition is violated, then transitions are aliased, and a planned transition may not", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 466, + 506, + 479 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 316, + 479 + ], + "score": 1.0, + "content": "be achievable by the policy from the particular state", + "type": "text" + }, + { + "bbox": [ + 317, + 469, + 323, + 477 + ], + "score": 0.71, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 466, + 506, + 479 + ], + "score": 1.0, + "content": "even though it’s achievable from other states", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 478, + 505, + 490 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 505, + 490 + ], + "score": 1.0, + "content": "with the same properties, causing the model to fail to achieve its goal. Note that in the experiments", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 487, + 263, + 501 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 263, + 501 + ], + "score": 1.0, + "content": "in 4.2, there will be nontrivial aliasing.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 420, + 506, + 501 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 514, + 209, + 525 + ], + "lines": [ + { + "bbox": [ + 105, + 513, + 210, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 210, + 527 + ], + "score": 1.0, + "content": "2.1 MODEL TRAINING", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 42 + }, + { + "type": "title", + "bbox": [ + 108, + 534, + 246, + 547 + ], + "lines": [ + { + "bbox": [ + 105, + 533, + 246, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 238, + 549 + ], + "score": 1.0, + "content": "2.1.1 ATTRIBUTE DETECTOR", + "type": "text" + }, + { + "bbox": [ + 238, + 534, + 246, + 547 + ], + "score": 0.78, + "content": "\\hat { f }", + "type": "inline_equation" + } + ], + "index": 43 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 107, + 556, + 505, + 601 + ], + "lines": [ + { + "bbox": [ + 105, + 555, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 373, + 569 + ], + "score": 1.0, + "content": "The first step of training consists of fitting the attribute detectors", + "type": "text" + }, + { + "bbox": [ + 374, + 555, + 381, + 568 + ], + "score": 0.88, + "content": "\\hat { f }", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 556, + 446, + 569 + ], + "score": 1.0, + "content": "that map states", + "type": "text" + }, + { + "bbox": [ + 447, + 559, + 453, + 567 + ], + "score": 0.73, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 556, + 505, + 569 + ], + "score": 1.0, + "content": "to attributes", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 107, + 568, + 505, + 580 + ], + "spans": [ + { + "bbox": [ + 107, + 570, + 113, + 579 + ], + "score": 0.71, + "content": "\\rho", + "type": "inline_equation" + }, + { + "bbox": [ + 113, + 568, + 505, + 580 + ], + "score": 1.0, + "content": ". As mentioned above, we assume that there is a set of labeled (state, attribute) examples we can", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 579, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 505, + 591 + ], + "score": 1.0, + "content": "use for fitting this part of the model. Note that these examples are the only supervision given to the", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 590, + 280, + 602 + ], + "spans": [ + { + "bbox": [ + 105, + 590, + 280, + 602 + ], + "score": 1.0, + "content": "model during the entire training procedure.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 45.5, + "bbox_fs": [ + 105, + 555, + 505, + 602 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 615, + 322, + 626 + ], + "lines": [ + { + "bbox": [ + 106, + 614, + 322, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 614, + 283, + 628 + ], + "score": 1.0, + "content": "2.1.2 ATTRIBUTE TRANSITION MODELS", + "type": "text" + }, + { + "bbox": [ + 284, + 618, + 290, + 625 + ], + "score": 0.37, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 614, + 312, + 628 + ], + "score": 1.0, + "content": "AND", + "type": "text" + }, + { + "bbox": [ + 312, + 617, + 322, + 626 + ], + "score": 0.69, + "content": "c _ { \\pi }", + "type": "inline_equation" + } + ], + "index": 48 + } + ], + "index": 48 + }, + { + "type": "text", + "bbox": [ + 107, + 634, + 505, + 701 + ], + "lines": [ + { + "bbox": [ + 106, + 635, + 505, + 646 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 160, + 646 + ], + "score": 1.0, + "content": "To construct", + "type": "text" + }, + { + "bbox": [ + 160, + 637, + 166, + 645 + ], + "score": 0.62, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 635, + 505, + 646 + ], + "score": 1.0, + "content": ", the agent samples transitions from the environment, finding the sets of attributes", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "score": 1.0, + "content": "which actually occur in the environment (from the potentially large number of all possible attributes).", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 656, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 656, + 426, + 669 + ], + "score": 1.0, + "content": "In the experiments below, we place the agent in a state at random with attributes", + "type": "text" + }, + { + "bbox": [ + 426, + 658, + 435, + 668 + ], + "score": 0.84, + "content": "\\rho _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 436, + 656, + 506, + 669 + ], + "score": 1.0, + "content": ". It will then take", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 667, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 472, + 680 + ], + "score": 1.0, + "content": "a random action, or short sequence of actions. These lead to a new state with attributes", + "type": "text" + }, + { + "bbox": [ + 472, + 669, + 483, + 680 + ], + "score": 0.85, + "content": "\\rho _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 667, + 506, + 680 + ], + "score": 1.0, + "content": ", and", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 107, + 678, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 107, + 678, + 142, + 690 + ], + "score": 0.92, + "content": "c ( \\rho _ { i } , \\rho _ { j } )", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 678, + 505, + 691 + ], + "score": 1.0, + "content": "is incremented. This is repeated many times, building up statistics on possible transitions", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 689, + 505, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 391, + 702 + ], + "score": 1.0, + "content": "within attribute space. The resulting table represents a transition graph", + "type": "text" + }, + { + "bbox": [ + 392, + 690, + 401, + 699 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 689, + 505, + 702 + ], + "score": 1.0, + "content": "with vertices given by all", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 105, + 82, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 120, + 96 + ], + "score": 1.0, + "content": "the", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 121, + 84, + 128, + 94 + ], + "score": 0.82, + "content": "\\rho", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 128, + 82, + 291, + 96 + ], + "score": 1.0, + "content": "the agent has seen, and an edge between", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 291, + 85, + 301, + 94 + ], + "score": 0.85, + "content": "\\rho _ { i }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 301, + 82, + 318, + 96 + ], + "score": 1.0, + "content": "and", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 319, + 84, + 330, + 95 + ], + "score": 0.87, + "content": "\\rho _ { j }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 330, + 82, + 506, + 96 + ], + "score": 1.0, + "content": "counting the number of times the transition", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 237, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 142, + 106 + ], + "score": 1.0, + "content": "between", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 142, + 96, + 152, + 105 + ], + "score": 0.84, + "content": "\\rho _ { i }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 152, + 93, + 169, + 106 + ], + "score": 1.0, + "content": "and", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 170, + 95, + 181, + 106 + ], + "score": 0.86, + "content": "\\rho _ { j }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 181, + 93, + 237, + 106 + ], + "score": 1.0, + "content": "has occurred.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + } + ], + "index": 51.5, + "bbox_fs": [ + 105, + 635, + 506, + 702 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 120, + 96 + ], + "score": 1.0, + "content": "the", + "type": "text" + }, + { + "bbox": [ + 121, + 84, + 128, + 94 + ], + "score": 0.82, + "content": "\\rho", + "type": "inline_equation" + }, + { + "bbox": [ + 128, + 82, + 291, + 96 + ], + "score": 1.0, + "content": "the agent has seen, and an edge between", + "type": "text" + }, + { + "bbox": [ + 291, + 85, + 301, + 94 + ], + "score": 0.85, + "content": "\\rho _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 301, + 82, + 318, + 96 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 319, + 84, + 330, + 95 + ], + "score": 0.87, + "content": "\\rho _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 82, + 506, + 96 + ], + "score": 1.0, + "content": "counting the number of times the transition", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 237, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 142, + 106 + ], + "score": 1.0, + "content": "between", + "type": "text" + }, + { + "bbox": [ + 142, + 96, + 152, + 105 + ], + "score": 0.84, + "content": "\\rho _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 93, + 169, + 106 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 170, + 95, + 181, + 106 + ], + "score": 0.86, + "content": "\\rho _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 93, + 237, + 106 + ], + "score": 1.0, + "content": "has occurred.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 106, + 110, + 505, + 200 + ], + "lines": [ + { + "bbox": [ + 105, + 110, + 506, + 123 + ], + "spans": [ + { + "bbox": [ + 105, + 110, + 249, + 123 + ], + "score": 1.0, + "content": "This procedure produces the graph", + "type": "text" + }, + { + "bbox": [ + 250, + 111, + 259, + 121 + ], + "score": 0.78, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 110, + 506, + 123 + ], + "score": 1.0, + "content": ", but the counts in the graph are not normalized probabilities", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 121, + 507, + 135 + ], + "spans": [ + { + "bbox": [ + 105, + 121, + 194, + 135 + ], + "score": 1.0, + "content": "of transitioning from", + "type": "text" + }, + { + "bbox": [ + 195, + 123, + 204, + 133 + ], + "score": 0.84, + "content": "\\rho _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 121, + 218, + 135 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 218, + 123, + 228, + 133 + ], + "score": 0.85, + "content": "\\rho _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 229, + 121, + 507, + 135 + ], + "score": 1.0, + "content": "(as we have never seen any negative samples). Therefore, given a", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 132, + 506, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 174, + 145 + ], + "score": 1.0, + "content": "low-level policy", + "type": "text" + }, + { + "bbox": [ + 174, + 134, + 182, + 142 + ], + "score": 0.74, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 132, + 506, + 145 + ], + "score": 1.0, + "content": "(see Sec. 2.1.3) we can optionally perform a second phase of training to learn", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 143, + 506, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 143, + 224, + 156 + ], + "score": 1.0, + "content": "the probability that for each", + "type": "text" + }, + { + "bbox": [ + 225, + 144, + 255, + 156 + ], + "score": 0.93, + "content": "( \\rho _ { i } , \\rho _ { j } )", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 143, + 340, + 156 + ], + "score": 1.0, + "content": "in the graph, that if", + "type": "text" + }, + { + "bbox": [ + 340, + 143, + 384, + 155 + ], + "score": 0.93, + "content": "\\rho _ { i } = f ( s )", + "type": "inline_equation" + }, + { + "bbox": [ + 384, + 143, + 407, + 156 + ], + "score": 1.0, + "content": "then", + "type": "text" + }, + { + "bbox": [ + 407, + 143, + 439, + 155 + ], + "score": 0.93, + "content": "\\pi ( s , \\rho _ { i } )", + "type": "inline_equation" + }, + { + "bbox": [ + 440, + 143, + 506, + 156 + ], + "score": 1.0, + "content": "will succeed at", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 154, + 506, + 168 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 171, + 168 + ], + "score": 1.0, + "content": "transitioning to", + "type": "text" + }, + { + "bbox": [ + 172, + 156, + 182, + 166 + ], + "score": 0.83, + "content": "\\rho _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 154, + 267, + 168 + ], + "score": 1.0, + "content": ". At a random state", + "type": "text" + }, + { + "bbox": [ + 267, + 156, + 273, + 164 + ], + "score": 0.65, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 274, + 154, + 337, + 168 + ], + "score": 1.0, + "content": "with attributes", + "type": "text" + }, + { + "bbox": [ + 337, + 156, + 347, + 166 + ], + "score": 0.84, + "content": "\\rho _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 154, + 388, + 168 + ], + "score": 1.0, + "content": ", we pick", + "type": "text" + }, + { + "bbox": [ + 388, + 156, + 399, + 166 + ], + "score": 0.84, + "content": "\\rho _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 154, + 506, + 168 + ], + "score": 1.0, + "content": "from the set of goals for", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 165, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 133, + 178 + ], + "score": 1.0, + "content": "which", + "type": "text" + }, + { + "bbox": [ + 134, + 165, + 188, + 177 + ], + "score": 0.92, + "content": "c ( \\rho _ { i } , \\rho _ { j } ) > 0", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 165, + 230, + 178 + ], + "score": 1.0, + "content": "and see if", + "type": "text" + }, + { + "bbox": [ + 230, + 167, + 237, + 175 + ], + "score": 0.8, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 238, + 165, + 506, + 178 + ], + "score": 1.0, + "content": "is able to achieve this goal. While doing this, we keep track of the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "score": 1.0, + "content": "fraction of attempts for which the policy was successful at this transition and store this probability", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 186, + 163, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 117, + 201 + ], + "score": 1.0, + "content": "in", + "type": "text" + }, + { + "bbox": [ + 117, + 187, + 157, + 200 + ], + "score": 0.93, + "content": "c _ { \\pi } ( \\rho _ { i } , \\rho _ { j } )", + "type": "inline_equation" + }, + { + "bbox": [ + 158, + 186, + 163, + 201 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 5.5 + }, + { + "type": "title", + "bbox": [ + 107, + 213, + 234, + 224 + ], + "lines": [ + { + "bbox": [ + 106, + 212, + 234, + 225 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 226, + 225 + ], + "score": 1.0, + "content": "2.1.3 LOW LEVEL POLICY", + "type": "text" + }, + { + "bbox": [ + 226, + 215, + 234, + 223 + ], + "score": 0.55, + "content": "\\pi", + "type": "inline_equation" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 106, + 232, + 505, + 321 + ], + "lines": [ + { + "bbox": [ + 104, + 231, + 506, + 246 + ], + "spans": [ + { + "bbox": [ + 104, + 231, + 275, + 246 + ], + "score": 1.0, + "content": "Finally, we need to train a policy network", + "type": "text" + }, + { + "bbox": [ + 276, + 233, + 329, + 245 + ], + "score": 0.93, + "content": "\\pi = \\pi ( s , \\rho _ { g } )", + "type": "inline_equation" + }, + { + "bbox": [ + 329, + 231, + 506, + 246 + ], + "score": 1.0, + "content": "to solve simple tasks, i.e. those that require", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 104, + 243, + 505, + 256 + ], + "spans": [ + { + "bbox": [ + 104, + 243, + 398, + 256 + ], + "score": 1.0, + "content": "a few actions to move between nearby attribute sets. One way of training", + "type": "text" + }, + { + "bbox": [ + 398, + 246, + 406, + 254 + ], + "score": 0.72, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 243, + 505, + 256 + ], + "score": 1.0, + "content": "is as an “inverse model”", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 104, + 254, + 506, + 268 + ], + "spans": [ + { + "bbox": [ + 104, + 254, + 506, + 268 + ], + "score": 1.0, + "content": "in the style of Agrawal et al. (2016); Andrychowicz et al. (2017). In the first phase of training", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 265, + 506, + 279 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 299, + 279 + ], + "score": 1.0, + "content": "the graph, suppose we sample each initial state", + "type": "text" + }, + { + "bbox": [ + 299, + 267, + 310, + 277 + ], + "score": 0.85, + "content": "s _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 265, + 408, + 279 + ], + "score": 1.0, + "content": "and an action sequence", + "type": "text" + }, + { + "bbox": [ + 409, + 266, + 466, + 277 + ], + "score": 0.93, + "content": "[ a _ { 0 } , a _ { 1 } , . . . , a _ { k } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 265, + 506, + 279 + ], + "score": 1.0, + "content": "from the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 277, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 106, + 277, + 409, + 289 + ], + "score": 1.0, + "content": "exploration policy, causing the agent to arrive at a new state with attributes", + "type": "text" + }, + { + "bbox": [ + 410, + 279, + 420, + 288 + ], + "score": 0.85, + "content": "\\rho _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 421, + 277, + 481, + 289 + ], + "score": 1.0, + "content": ". We then treat", + "type": "text" + }, + { + "bbox": [ + 482, + 279, + 493, + 288 + ], + "score": 0.84, + "content": "a _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 493, + 277, + 505, + 289 + ], + "score": 1.0, + "content": "as", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 287, + 506, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 203, + 300 + ], + "score": 1.0, + "content": "the “correct” action for", + "type": "text" + }, + { + "bbox": [ + 203, + 288, + 241, + 299 + ], + "score": 0.93, + "content": "\\pi ( s _ { 0 } , \\rho _ { 1 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 287, + 467, + 300 + ], + "score": 1.0, + "content": "and update its parameters for this target. Alternatively,", + "type": "text" + }, + { + "bbox": [ + 467, + 289, + 475, + 298 + ], + "score": 0.7, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 287, + 506, + 300 + ], + "score": 1.0, + "content": "can be", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 298, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 344, + 312 + ], + "score": 1.0, + "content": "trained using reinforcement learning. After an initial graph", + "type": "text" + }, + { + "bbox": [ + 344, + 300, + 351, + 308 + ], + "score": 0.76, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 298, + 505, + 312 + ], + "score": 1.0, + "content": "is constructed, tasks can be chosen by", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 310, + 369, + 322 + ], + "spans": [ + { + "bbox": [ + 106, + 310, + 369, + 322 + ], + "score": 1.0, + "content": "sampling from states nearby the initial or current state properties.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14.5 + }, + { + "type": "title", + "bbox": [ + 107, + 336, + 240, + 347 + ], + "lines": [ + { + "bbox": [ + 106, + 336, + 241, + 349 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 241, + 349 + ], + "score": 1.0, + "content": "2.2 EVALUATING THE MODEL", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 357, + 505, + 391 + ], + "lines": [ + { + "bbox": [ + 105, + 356, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 455, + 371 + ], + "score": 1.0, + "content": "Once the model has been built we can use it for planning. That is, given an input state", + "type": "text" + }, + { + "bbox": [ + 456, + 360, + 461, + 367 + ], + "score": 0.77, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 356, + 505, + 371 + ], + "score": 1.0, + "content": "and target", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 367, + 504, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 172, + 383 + ], + "score": 1.0, + "content": "set of attributes", + "type": "text" + }, + { + "bbox": [ + 172, + 371, + 185, + 380 + ], + "score": 0.84, + "content": "\\rho _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 367, + 250, + 383 + ], + "score": 1.0, + "content": ", we find a path", + "type": "text" + }, + { + "bbox": [ + 251, + 369, + 311, + 381 + ], + "score": 0.93, + "content": "[ \\rho _ { 0 } , \\rho _ { 1 } , . . . , \\rho _ { m } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 367, + 367, + 383 + ], + "score": 1.0, + "content": "on the graph", + "type": "text" + }, + { + "bbox": [ + 367, + 369, + 376, + 379 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 367, + 398, + 383 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 399, + 369, + 443, + 381 + ], + "score": 0.93, + "content": "\\rho _ { 0 } = f ( s )", + "type": "inline_equation" + }, + { + "bbox": [ + 443, + 367, + 462, + 383 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 463, + 370, + 504, + 380 + ], + "score": 0.88, + "content": "\\rho _ { m } = \\rho _ { T }", + "type": "inline_equation" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 378, + 158, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 158, + 393 + ], + "score": 1.0, + "content": "maximizing", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21 + }, + { + "type": "interline_equation", + "bbox": [ + 261, + 392, + 349, + 426 + ], + "lines": [ + { + "bbox": [ + 261, + 392, + 349, + 426 + ], + "spans": [ + { + "bbox": [ + 261, + 392, + 349, + 426 + ], + "score": 0.94, + "content": "\\sum _ { i = 0 } ^ { m - 1 } \\log c _ { \\pi } ( \\rho _ { i } , \\rho _ { i + 1 } ) .", + "type": "interline_equation", + "image_path": "0b299f9ab4cb3b839c7e98bc6921e62f6d64da9d1a1b5fbe93046c59a5a845b9.jpg" + } + ] + } + ], + "index": 23.5, + "virtual_lines": [ + { + "bbox": [ + 261, + 392, + 349, + 409.0 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 261, + 409.0, + 349, + 426.0 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 430, + 505, + 497 + ], + "lines": [ + { + "bbox": [ + 106, + 430, + 506, + 443 + ], + "spans": [ + { + "bbox": [ + 106, + 430, + 506, + 443 + ], + "score": 1.0, + "content": "The optimal path can be found using Dijkstra’s algorithm with a distance metric of", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 441, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 186, + 453 + ], + "score": 0.89, + "content": "- \\log ( c _ { \\pi } ( \\rho _ { i } , \\rho _ { i + 1 } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 441, + 506, + 455 + ], + "score": 1.0, + "content": ". The policy is then used to move along the resulting path between attribute set,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 104, + 451, + 506, + 465 + ], + "spans": [ + { + "bbox": [ + 104, + 451, + 237, + 465 + ], + "score": 1.0, + "content": "i.e. we take actions according to", + "type": "text" + }, + { + "bbox": [ + 237, + 452, + 289, + 464 + ], + "score": 0.93, + "content": "a = \\pi ( s , \\rho _ { 1 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 451, + 334, + 465 + ], + "score": 1.0, + "content": ", then once", + "type": "text" + }, + { + "bbox": [ + 334, + 452, + 376, + 464 + ], + "score": 0.92, + "content": "{ \\bar { f ( s ) } } = \\rho _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 451, + 435, + 465 + ], + "score": 1.0, + "content": ", we change to", + "type": "text" + }, + { + "bbox": [ + 435, + 452, + 487, + 464 + ], + "score": 0.93, + "content": "a = \\pi ( s , \\rho _ { 2 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 451, + 506, + 465 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 463, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 505, + 475 + ], + "score": 1.0, + "content": "so on. At each intermediate step, if the current attributes don’t match the attributes on the computed", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 474, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 505, + 487 + ], + "score": 1.0, + "content": "path, then a new path is computed using the current attributes as a starting point (or, equivalently,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 485, + 281, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 281, + 497 + ], + "score": 1.0, + "content": "the whole path is recomputed at each step).", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27.5 + }, + { + "type": "title", + "bbox": [ + 108, + 514, + 209, + 527 + ], + "lines": [ + { + "bbox": [ + 105, + 513, + 210, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 210, + 529 + ], + "score": 1.0, + "content": "3 RELATED WORK", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 540, + 505, + 607 + ], + "lines": [ + { + "bbox": [ + 105, + 540, + 506, + 553 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 553 + ], + "score": 1.0, + "content": "Hierarchical RL Many researchers have recognized the importance of methods that can divide a", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 552, + 504, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 504, + 563 + ], + "score": 1.0, + "content": "MDP into subprocesses (Thrun & Schwartz, 1994; Parr & Russell, 1998; Sutton et al., 1999; Diet-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 563, + 504, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 504, + 575 + ], + "score": 1.0, + "content": "terich, 2000). Perhaps the most standard formalism today is the options framework of (Sutton et al.,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 573, + 505, + 586 + ], + "spans": [ + { + "bbox": [ + 106, + 573, + 505, + 586 + ], + "score": 1.0, + "content": "1999), which deals with multistep “macro-actions” in the setting of reinforcement learning. Recent", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 584, + 505, + 597 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 505, + 597 + ], + "score": 1.0, + "content": "works, like Kulkarni et al. (2016), have shown how options can be used with function approximation", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 595, + 180, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 180, + 609 + ], + "score": 1.0, + "content": "via deep learning.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 34.5 + }, + { + "type": "text", + "bbox": [ + 106, + 612, + 505, + 690 + ], + "lines": [ + { + "bbox": [ + 106, + 612, + 505, + 625 + ], + "spans": [ + { + "bbox": [ + 106, + 612, + 505, + 625 + ], + "score": 1.0, + "content": "Our work is also a hierarchical approach to controlling an agent in a Markovian environment. How-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 623, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 623, + 505, + 636 + ], + "score": 1.0, + "content": "ever, the paradigm we consider differs from reinforcement learning: we consider a setup where no", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 634, + 504, + 646 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 305, + 646 + ], + "score": 1.0, + "content": "reward or supervision is provided other than the", + "type": "text" + }, + { + "bbox": [ + 306, + 634, + 340, + 646 + ], + "score": 0.9, + "content": "( s , \\rho ( s ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 635, + 504, + 646 + ], + "score": 1.0, + "content": "pairs, and show than an agent can learn", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 645, + 506, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 288, + 658 + ], + "score": 1.0, + "content": "to decompose a transition between far away", + "type": "text" + }, + { + "bbox": [ + 288, + 646, + 307, + 657 + ], + "score": 0.89, + "content": "\\rho , \\rho ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 645, + 506, + 658 + ], + "score": 1.0, + "content": "into a sequence of short transitions. If we were", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 104, + 656, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 104, + 656, + 304, + 669 + ], + "score": 1.0, + "content": "to frame the problem as HRL, considering each", + "type": "text" + }, + { + "bbox": [ + 304, + 657, + 331, + 668 + ], + "score": 0.92, + "content": "\\pi ( \\cdot , \\rho )", + "type": "inline_equation" + }, + { + "bbox": [ + 332, + 656, + 506, + 669 + ], + "score": 1.0, + "content": "as a macro action2, in order for the agent", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 204, + 679 + ], + "score": 1.0, + "content": "to learn to sequence the", + "type": "text" + }, + { + "bbox": [ + 205, + 667, + 235, + 679 + ], + "score": 0.92, + "content": "\\pi ( \\cdot , \\rho _ { i } )", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 667, + 505, + 679 + ], + "score": 1.0, + "content": ", the environment would need to give reward for the completion of", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 679, + 253, + 691 + ], + "spans": [ + { + "bbox": [ + 106, + 679, + 253, + 691 + ], + "score": 1.0, + "content": "complex tasks, not just simple ones.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 41 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 701, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 117, + 699, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 117, + 699, + 506, + 714 + ], + "score": 1.0, + "content": "2Note also that all the “macro actions’ in our examples in 4.2 are degenerate in the sense that they return", + "type": "text" + } + ] + }, + { + "bbox": [ + 105, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "after one step, but we still are able to show generalization to long trajectories from (unsupervised) training only", + "type": "text" + } + ] + }, + { + "bbox": [ + 105, + 721, + 157, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 157, + 732 + ], + "score": 1.0, + "content": "on short ones", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [], + "index": 0.5, + "bbox_fs": [ + 105, + 82, + 506, + 106 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 110, + 505, + 200 + ], + "lines": [ + { + "bbox": [ + 105, + 110, + 506, + 123 + ], + "spans": [ + { + "bbox": [ + 105, + 110, + 249, + 123 + ], + "score": 1.0, + "content": "This procedure produces the graph", + "type": "text" + }, + { + "bbox": [ + 250, + 111, + 259, + 121 + ], + "score": 0.78, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 110, + 506, + 123 + ], + "score": 1.0, + "content": ", but the counts in the graph are not normalized probabilities", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 121, + 507, + 135 + ], + "spans": [ + { + "bbox": [ + 105, + 121, + 194, + 135 + ], + "score": 1.0, + "content": "of transitioning from", + "type": "text" + }, + { + "bbox": [ + 195, + 123, + 204, + 133 + ], + "score": 0.84, + "content": "\\rho _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 121, + 218, + 135 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 218, + 123, + 228, + 133 + ], + "score": 0.85, + "content": "\\rho _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 229, + 121, + 507, + 135 + ], + "score": 1.0, + "content": "(as we have never seen any negative samples). Therefore, given a", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 132, + 506, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 174, + 145 + ], + "score": 1.0, + "content": "low-level policy", + "type": "text" + }, + { + "bbox": [ + 174, + 134, + 182, + 142 + ], + "score": 0.74, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 132, + 506, + 145 + ], + "score": 1.0, + "content": "(see Sec. 2.1.3) we can optionally perform a second phase of training to learn", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 143, + 506, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 143, + 224, + 156 + ], + "score": 1.0, + "content": "the probability that for each", + "type": "text" + }, + { + "bbox": [ + 225, + 144, + 255, + 156 + ], + "score": 0.93, + "content": "( \\rho _ { i } , \\rho _ { j } )", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 143, + 340, + 156 + ], + "score": 1.0, + "content": "in the graph, that if", + "type": "text" + }, + { + "bbox": [ + 340, + 143, + 384, + 155 + ], + "score": 0.93, + "content": "\\rho _ { i } = f ( s )", + "type": "inline_equation" + }, + { + "bbox": [ + 384, + 143, + 407, + 156 + ], + "score": 1.0, + "content": "then", + "type": "text" + }, + { + "bbox": [ + 407, + 143, + 439, + 155 + ], + "score": 0.93, + "content": "\\pi ( s , \\rho _ { i } )", + "type": "inline_equation" + }, + { + "bbox": [ + 440, + 143, + 506, + 156 + ], + "score": 1.0, + "content": "will succeed at", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 154, + 506, + 168 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 171, + 168 + ], + "score": 1.0, + "content": "transitioning to", + "type": "text" + }, + { + "bbox": [ + 172, + 156, + 182, + 166 + ], + "score": 0.83, + "content": "\\rho _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 154, + 267, + 168 + ], + "score": 1.0, + "content": ". At a random state", + "type": "text" + }, + { + "bbox": [ + 267, + 156, + 273, + 164 + ], + "score": 0.65, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 274, + 154, + 337, + 168 + ], + "score": 1.0, + "content": "with attributes", + "type": "text" + }, + { + "bbox": [ + 337, + 156, + 347, + 166 + ], + "score": 0.84, + "content": "\\rho _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 154, + 388, + 168 + ], + "score": 1.0, + "content": ", we pick", + "type": "text" + }, + { + "bbox": [ + 388, + 156, + 399, + 166 + ], + "score": 0.84, + "content": "\\rho _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 154, + 506, + 168 + ], + "score": 1.0, + "content": "from the set of goals for", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 165, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 133, + 178 + ], + "score": 1.0, + "content": "which", + "type": "text" + }, + { + "bbox": [ + 134, + 165, + 188, + 177 + ], + "score": 0.92, + "content": "c ( \\rho _ { i } , \\rho _ { j } ) > 0", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 165, + 230, + 178 + ], + "score": 1.0, + "content": "and see if", + "type": "text" + }, + { + "bbox": [ + 230, + 167, + 237, + 175 + ], + "score": 0.8, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 238, + 165, + 506, + 178 + ], + "score": 1.0, + "content": "is able to achieve this goal. While doing this, we keep track of the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "score": 1.0, + "content": "fraction of attempts for which the policy was successful at this transition and store this probability", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 186, + 163, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 117, + 201 + ], + "score": 1.0, + "content": "in", + "type": "text" + }, + { + "bbox": [ + 117, + 187, + 157, + 200 + ], + "score": 0.93, + "content": "c _ { \\pi } ( \\rho _ { i } , \\rho _ { j } )", + "type": "inline_equation" + }, + { + "bbox": [ + 158, + 186, + 163, + 201 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 5.5, + "bbox_fs": [ + 105, + 110, + 507, + 201 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 213, + 234, + 224 + ], + "lines": [ + { + "bbox": [ + 106, + 212, + 234, + 225 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 226, + 225 + ], + "score": 1.0, + "content": "2.1.3 LOW LEVEL POLICY", + "type": "text" + }, + { + "bbox": [ + 226, + 215, + 234, + 223 + ], + "score": 0.55, + "content": "\\pi", + "type": "inline_equation" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 106, + 232, + 505, + 321 + ], + "lines": [ + { + "bbox": [ + 104, + 231, + 506, + 246 + ], + "spans": [ + { + "bbox": [ + 104, + 231, + 275, + 246 + ], + "score": 1.0, + "content": "Finally, we need to train a policy network", + "type": "text" + }, + { + "bbox": [ + 276, + 233, + 329, + 245 + ], + "score": 0.93, + "content": "\\pi = \\pi ( s , \\rho _ { g } )", + "type": "inline_equation" + }, + { + "bbox": [ + 329, + 231, + 506, + 246 + ], + "score": 1.0, + "content": "to solve simple tasks, i.e. those that require", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 104, + 243, + 505, + 256 + ], + "spans": [ + { + "bbox": [ + 104, + 243, + 398, + 256 + ], + "score": 1.0, + "content": "a few actions to move between nearby attribute sets. One way of training", + "type": "text" + }, + { + "bbox": [ + 398, + 246, + 406, + 254 + ], + "score": 0.72, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 243, + 505, + 256 + ], + "score": 1.0, + "content": "is as an “inverse model”", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 104, + 254, + 506, + 268 + ], + "spans": [ + { + "bbox": [ + 104, + 254, + 506, + 268 + ], + "score": 1.0, + "content": "in the style of Agrawal et al. (2016); Andrychowicz et al. (2017). In the first phase of training", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 265, + 506, + 279 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 299, + 279 + ], + "score": 1.0, + "content": "the graph, suppose we sample each initial state", + "type": "text" + }, + { + "bbox": [ + 299, + 267, + 310, + 277 + ], + "score": 0.85, + "content": "s _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 265, + 408, + 279 + ], + "score": 1.0, + "content": "and an action sequence", + "type": "text" + }, + { + "bbox": [ + 409, + 266, + 466, + 277 + ], + "score": 0.93, + "content": "[ a _ { 0 } , a _ { 1 } , . . . , a _ { k } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 265, + 506, + 279 + ], + "score": 1.0, + "content": "from the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 277, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 106, + 277, + 409, + 289 + ], + "score": 1.0, + "content": "exploration policy, causing the agent to arrive at a new state with attributes", + "type": "text" + }, + { + "bbox": [ + 410, + 279, + 420, + 288 + ], + "score": 0.85, + "content": "\\rho _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 421, + 277, + 481, + 289 + ], + "score": 1.0, + "content": ". We then treat", + "type": "text" + }, + { + "bbox": [ + 482, + 279, + 493, + 288 + ], + "score": 0.84, + "content": "a _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 493, + 277, + 505, + 289 + ], + "score": 1.0, + "content": "as", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 287, + 506, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 203, + 300 + ], + "score": 1.0, + "content": "the “correct” action for", + "type": "text" + }, + { + "bbox": [ + 203, + 288, + 241, + 299 + ], + "score": 0.93, + "content": "\\pi ( s _ { 0 } , \\rho _ { 1 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 287, + 467, + 300 + ], + "score": 1.0, + "content": "and update its parameters for this target. Alternatively,", + "type": "text" + }, + { + "bbox": [ + 467, + 289, + 475, + 298 + ], + "score": 0.7, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 287, + 506, + 300 + ], + "score": 1.0, + "content": "can be", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 298, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 344, + 312 + ], + "score": 1.0, + "content": "trained using reinforcement learning. After an initial graph", + "type": "text" + }, + { + "bbox": [ + 344, + 300, + 351, + 308 + ], + "score": 0.76, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 298, + 505, + 312 + ], + "score": 1.0, + "content": "is constructed, tasks can be chosen by", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 310, + 369, + 322 + ], + "spans": [ + { + "bbox": [ + 106, + 310, + 369, + 322 + ], + "score": 1.0, + "content": "sampling from states nearby the initial or current state properties.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14.5, + "bbox_fs": [ + 104, + 231, + 506, + 322 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 336, + 240, + 347 + ], + "lines": [ + { + "bbox": [ + 106, + 336, + 241, + 349 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 241, + 349 + ], + "score": 1.0, + "content": "2.2 EVALUATING THE MODEL", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 357, + 505, + 391 + ], + "lines": [ + { + "bbox": [ + 105, + 356, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 455, + 371 + ], + "score": 1.0, + "content": "Once the model has been built we can use it for planning. That is, given an input state", + "type": "text" + }, + { + "bbox": [ + 456, + 360, + 461, + 367 + ], + "score": 0.77, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 356, + 505, + 371 + ], + "score": 1.0, + "content": "and target", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 367, + 504, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 172, + 383 + ], + "score": 1.0, + "content": "set of attributes", + "type": "text" + }, + { + "bbox": [ + 172, + 371, + 185, + 380 + ], + "score": 0.84, + "content": "\\rho _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 367, + 250, + 383 + ], + "score": 1.0, + "content": ", we find a path", + "type": "text" + }, + { + "bbox": [ + 251, + 369, + 311, + 381 + ], + "score": 0.93, + "content": "[ \\rho _ { 0 } , \\rho _ { 1 } , . . . , \\rho _ { m } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 367, + 367, + 383 + ], + "score": 1.0, + "content": "on the graph", + "type": "text" + }, + { + "bbox": [ + 367, + 369, + 376, + 379 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 367, + 398, + 383 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 399, + 369, + 443, + 381 + ], + "score": 0.93, + "content": "\\rho _ { 0 } = f ( s )", + "type": "inline_equation" + }, + { + "bbox": [ + 443, + 367, + 462, + 383 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 463, + 370, + 504, + 380 + ], + "score": 0.88, + "content": "\\rho _ { m } = \\rho _ { T }", + "type": "inline_equation" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 378, + 158, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 158, + 393 + ], + "score": 1.0, + "content": "maximizing", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 356, + 505, + 393 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 261, + 392, + 349, + 426 + ], + "lines": [ + { + "bbox": [ + 261, + 392, + 349, + 426 + ], + "spans": [ + { + "bbox": [ + 261, + 392, + 349, + 426 + ], + "score": 0.94, + "content": "\\sum _ { i = 0 } ^ { m - 1 } \\log c _ { \\pi } ( \\rho _ { i } , \\rho _ { i + 1 } ) .", + "type": "interline_equation", + "image_path": "0b299f9ab4cb3b839c7e98bc6921e62f6d64da9d1a1b5fbe93046c59a5a845b9.jpg" + } + ] + } + ], + "index": 23.5, + "virtual_lines": [ + { + "bbox": [ + 261, + 392, + 349, + 409.0 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 261, + 409.0, + 349, + 426.0 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 430, + 505, + 497 + ], + "lines": [ + { + "bbox": [ + 106, + 430, + 506, + 443 + ], + "spans": [ + { + "bbox": [ + 106, + 430, + 506, + 443 + ], + "score": 1.0, + "content": "The optimal path can be found using Dijkstra’s algorithm with a distance metric of", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 441, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 186, + 453 + ], + "score": 0.89, + "content": "- \\log ( c _ { \\pi } ( \\rho _ { i } , \\rho _ { i + 1 } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 441, + 506, + 455 + ], + "score": 1.0, + "content": ". The policy is then used to move along the resulting path between attribute set,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 104, + 451, + 506, + 465 + ], + "spans": [ + { + "bbox": [ + 104, + 451, + 237, + 465 + ], + "score": 1.0, + "content": "i.e. we take actions according to", + "type": "text" + }, + { + "bbox": [ + 237, + 452, + 289, + 464 + ], + "score": 0.93, + "content": "a = \\pi ( s , \\rho _ { 1 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 451, + 334, + 465 + ], + "score": 1.0, + "content": ", then once", + "type": "text" + }, + { + "bbox": [ + 334, + 452, + 376, + 464 + ], + "score": 0.92, + "content": "{ \\bar { f ( s ) } } = \\rho _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 451, + 435, + 465 + ], + "score": 1.0, + "content": ", we change to", + "type": "text" + }, + { + "bbox": [ + 435, + 452, + 487, + 464 + ], + "score": 0.93, + "content": "a = \\pi ( s , \\rho _ { 2 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 451, + 506, + 465 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 463, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 505, + 475 + ], + "score": 1.0, + "content": "so on. At each intermediate step, if the current attributes don’t match the attributes on the computed", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 474, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 505, + 487 + ], + "score": 1.0, + "content": "path, then a new path is computed using the current attributes as a starting point (or, equivalently,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 485, + 281, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 281, + 497 + ], + "score": 1.0, + "content": "the whole path is recomputed at each step).", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27.5, + "bbox_fs": [ + 104, + 430, + 506, + 497 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 514, + 209, + 527 + ], + "lines": [ + { + "bbox": [ + 105, + 513, + 210, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 210, + 529 + ], + "score": 1.0, + "content": "3 RELATED WORK", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 540, + 505, + 607 + ], + "lines": [ + { + "bbox": [ + 105, + 540, + 506, + 553 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 553 + ], + "score": 1.0, + "content": "Hierarchical RL Many researchers have recognized the importance of methods that can divide a", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 552, + 504, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 504, + 563 + ], + "score": 1.0, + "content": "MDP into subprocesses (Thrun & Schwartz, 1994; Parr & Russell, 1998; Sutton et al., 1999; Diet-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 563, + 504, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 504, + 575 + ], + "score": 1.0, + "content": "terich, 2000). Perhaps the most standard formalism today is the options framework of (Sutton et al.,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 573, + 505, + 586 + ], + "spans": [ + { + "bbox": [ + 106, + 573, + 505, + 586 + ], + "score": 1.0, + "content": "1999), which deals with multistep “macro-actions” in the setting of reinforcement learning. Recent", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 584, + 505, + 597 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 505, + 597 + ], + "score": 1.0, + "content": "works, like Kulkarni et al. (2016), have shown how options can be used with function approximation", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 595, + 180, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 180, + 609 + ], + "score": 1.0, + "content": "via deep learning.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 540, + 506, + 609 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 612, + 505, + 690 + ], + "lines": [ + { + "bbox": [ + 106, + 612, + 505, + 625 + ], + "spans": [ + { + "bbox": [ + 106, + 612, + 505, + 625 + ], + "score": 1.0, + "content": "Our work is also a hierarchical approach to controlling an agent in a Markovian environment. How-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 623, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 623, + 505, + 636 + ], + "score": 1.0, + "content": "ever, the paradigm we consider differs from reinforcement learning: we consider a setup where no", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 634, + 504, + 646 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 305, + 646 + ], + "score": 1.0, + "content": "reward or supervision is provided other than the", + "type": "text" + }, + { + "bbox": [ + 306, + 634, + 340, + 646 + ], + "score": 0.9, + "content": "( s , \\rho ( s ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 635, + 504, + 646 + ], + "score": 1.0, + "content": "pairs, and show than an agent can learn", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 645, + 506, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 288, + 658 + ], + "score": 1.0, + "content": "to decompose a transition between far away", + "type": "text" + }, + { + "bbox": [ + 288, + 646, + 307, + 657 + ], + "score": 0.89, + "content": "\\rho , \\rho ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 645, + 506, + 658 + ], + "score": 1.0, + "content": "into a sequence of short transitions. If we were", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 104, + 656, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 104, + 656, + 304, + 669 + ], + "score": 1.0, + "content": "to frame the problem as HRL, considering each", + "type": "text" + }, + { + "bbox": [ + 304, + 657, + 331, + 668 + ], + "score": 0.92, + "content": "\\pi ( \\cdot , \\rho )", + "type": "inline_equation" + }, + { + "bbox": [ + 332, + 656, + 506, + 669 + ], + "score": 1.0, + "content": "as a macro action2, in order for the agent", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 204, + 679 + ], + "score": 1.0, + "content": "to learn to sequence the", + "type": "text" + }, + { + "bbox": [ + 205, + 667, + 235, + 679 + ], + "score": 0.92, + "content": "\\pi ( \\cdot , \\rho _ { i } )", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 667, + 505, + 679 + ], + "score": 1.0, + "content": ", the environment would need to give reward for the completion of", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 679, + 253, + 691 + ], + "spans": [ + { + "bbox": [ + 106, + 679, + 253, + 691 + ], + "score": 1.0, + "content": "complex tasks, not just simple ones.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 41, + "bbox_fs": [ + 104, + 612, + 506, + 691 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "As opposed to e.g. Kulkarni et al. (2016), where additional human supervision is used to allow ex-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 107 + ], + "score": 1.0, + "content": "ploration in the face of extremely sparse rewards, our goal is to show that adding human supervision", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 453, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 453, + 118 + ], + "score": 1.0, + "content": "to parameterize the task space via attributes allows compositionality through planning.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 121, + 505, + 209 + ], + "lines": [ + { + "bbox": [ + 105, + 120, + 505, + 133 + ], + "spans": [ + { + "bbox": [ + 105, + 120, + 505, + 133 + ], + "score": 1.0, + "content": "Horde and descendants Our work is related to generalized value functions (Sutton et al., 2011)", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 132, + 506, + 144 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 506, + 144 + ], + "score": 1.0, + "content": "in that we have policies parameterized by state and target attributes. In particular, if we used a", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 143, + 506, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 143, + 209, + 156 + ], + "score": 1.0, + "content": "parameterized model for", + "type": "text" + }, + { + "bbox": [ + 209, + 146, + 215, + 153 + ], + "score": 0.53, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 215, + 143, + 506, + 156 + ], + "score": 1.0, + "content": ", it would be similar to the factored state-goal representation in Schaul", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 154, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 505, + 167 + ], + "score": 1.0, + "content": "et al. (2015). Recently, van Seijen et al. (2017) used human provided attributes as a general value", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "score": 1.0, + "content": "function (GVF) in Ms. Pacman, showing that using a weighted combination of these can lead to", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 176, + 506, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 506, + 189 + ], + "score": 1.0, + "content": "higher scores than standard rewards. Although the representation used in that work is similar to", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "score": 1.0, + "content": "the one we use, the motivation in our work is to allow generalization to new tasks; and we use the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 392, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 392, + 211 + ], + "score": 1.0, + "content": "attributes to plan, rather than just as tools for building a reactive policy.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 107, + 214, + 505, + 313 + ], + "lines": [ + { + "bbox": [ + 106, + 215, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 106, + 215, + 505, + 227 + ], + "score": 1.0, + "content": "Factored MDP and Relational MDP Our approach is closely related to factored MDP (Boutilier", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 226, + 505, + 238 + ], + "spans": [ + { + "bbox": [ + 105, + 226, + 505, + 238 + ], + "score": 1.0, + "content": "et al., 1995; 2000; Guestrin et al., 2003b). In these works, it is assumed that the environment can", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 237, + 505, + 249 + ], + "spans": [ + { + "bbox": [ + 105, + 237, + 505, + 249 + ], + "score": 1.0, + "content": "be represented by discrete attributes, and that transitions between the attributes by an action can be", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 248, + 505, + 260 + ], + "spans": [ + { + "bbox": [ + 106, + 248, + 505, + 260 + ], + "score": 1.0, + "content": "modeled as a Bayesian network. The value of each attribute after an action is postulated to depend", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 258, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 258, + 505, + 271 + ], + "score": 1.0, + "content": "in a known way on attributes from before the action. The present work differs from these in that the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 270, + 505, + 283 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 505, + 283 + ], + "score": 1.0, + "content": "attributes do not determine the state and the dependency graph is not assumed to be known. More", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 281, + 506, + 294 + ], + "spans": [ + { + "bbox": [ + 105, + 281, + 506, + 294 + ], + "score": 1.0, + "content": "importantly, the focus in this work is on organizing the space of tasks through the attributes rather", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 291, + 505, + 305 + ], + "spans": [ + { + "bbox": [ + 105, + 291, + 505, + 305 + ], + "score": 1.0, + "content": "than being able to better plan a specific task; and in particular being able to generalize to new, more", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 303, + 214, + 315 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 214, + 315 + ], + "score": 1.0, + "content": "complex tasks at test time.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 107, + 319, + 505, + 418 + ], + "lines": [ + { + "bbox": [ + 105, + 320, + 505, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 505, + 332 + ], + "score": 1.0, + "content": "Our approach is also related to Relational MDP and Object Oriented MDP (Hernandez-Gardiol &", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 331, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 331, + 505, + 343 + ], + "score": 1.0, + "content": "Kaelbling, 2003; van Otterlo, 2005; Diuk et al., 2008; Abel et al., 2015), where states are described", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 342, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 342, + 505, + 353 + ], + "score": 1.0, + "content": "as a set of objects, each of which is an instantiation of canonical classes, and each instantiated object", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 353, + 505, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 505, + 365 + ], + "score": 1.0, + "content": "has a set of attributes. Our work is especially related to Guestrin et al. (2003a), where the aim is to", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 363, + 506, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 506, + 376 + ], + "score": 1.0, + "content": "show that by using a relational representation of an MDP, a policy from one domain can generalize", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 375, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 505, + 387 + ], + "score": 1.0, + "content": "to a new domain. However, in the current work, the attributes are taken directly as functions of the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 385, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 505, + 398 + ], + "score": 1.0, + "content": "state, as opposed to defined for object classes, and we do not have any explicit encoding of how", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 396, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 505, + 410 + ], + "score": 1.0, + "content": "objects interact. The model is given some examples of various attributes, and builds a parameterized", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 407, + 249, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 407, + 249, + 420 + ], + "score": 1.0, + "content": "model that maps into the attributes.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 107, + 424, + 505, + 514 + ], + "lines": [ + { + "bbox": [ + 106, + 424, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 106, + 424, + 505, + 436 + ], + "score": 1.0, + "content": "The Programmable Agents of Denil et al. (2017) put the notions of objects and attributes (as in", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 436, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 436, + 505, + 447 + ], + "score": 1.0, + "content": "relational MDP) into an end-to-end differentiable neural architecture. Our work is similar to this", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 446, + 506, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 368, + 460 + ], + "score": 1.0, + "content": "one in that it includes learned mappings from states to attributes", + "type": "text" + }, + { + "bbox": [ + 368, + 446, + 376, + 459 + ], + "score": 0.72, + "content": "\\hat { f }", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 447, + 506, + 460 + ], + "score": 1.0, + "content": "in our work, detectors in theirs;", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 459, + 505, + 470 + ], + "spans": [ + { + "bbox": [ + 106, + 459, + 505, + 470 + ], + "score": 1.0, + "content": "although we do not learn these end-to-end), and experiments in the setting of manipulating blocks", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 470, + 505, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 505, + 482 + ], + "score": 1.0, + "content": "in a physics simulator. On the other hand, our model uses explicit search instead of an end-to-end", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 480, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 505, + 492 + ], + "score": 1.0, + "content": "neural architecture to reason over attributes. Moreover, in Denil et al. (2017), the agent is trained", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 492, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 505, + 504 + ], + "score": 1.0, + "content": "and tested on similar tasks, but the object properties at test are novel; whereas our model is trained", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 502, + 303, + 515 + ], + "spans": [ + { + "bbox": [ + 106, + 502, + 303, + 515 + ], + "score": 1.0, + "content": "on simple tasks but generalizes to complex ones.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 32.5 + }, + { + "type": "title", + "bbox": [ + 107, + 519, + 365, + 531 + ], + "lines": [ + { + "bbox": [ + 105, + 517, + 366, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 366, + 533 + ], + "score": 1.0, + "content": "Lifelong learning, multitask learning, and zero-shot learning", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 536, + 505, + 624 + ], + "lines": [ + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "score": 1.0, + "content": "There is a large literature on quickly adapting to a new learning problem given a set or a history", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 546, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 505, + 560 + ], + "score": 1.0, + "content": "of related learning problems. Our approach in this work shares ideas with the one in Isele et al.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 558, + 505, + 570 + ], + "spans": [ + { + "bbox": [ + 106, + 558, + 505, + 570 + ], + "score": 1.0, + "content": "(2016), where tasks are augmented with descriptors and featurized. Our attributes correspond to", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 570, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 570, + 505, + 581 + ], + "score": 1.0, + "content": "these features. In that work, the coefficients of the task features in a sparse dictionary are used to", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 580, + 504, + 591 + ], + "spans": [ + { + "bbox": [ + 106, + 580, + 504, + 591 + ], + "score": 1.0, + "content": "weight a set of vectors defining the model for the associated task. In our work, the low level actor", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 591, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 505, + 603 + ], + "score": 1.0, + "content": "takes in the task features, but we learn how to transit between sets of features, and plan in that space.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 601, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 601, + 505, + 614 + ], + "score": 1.0, + "content": "Similarly, the task is specified by a feature as an input into a model in Lopez-Paz & Ranzato (2017),", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 613, + 394, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 394, + 626 + ], + "score": 1.0, + "content": "again this corresponds to the way our low-level actor processes its goal.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 41.5 + }, + { + "type": "text", + "bbox": [ + 107, + 630, + 505, + 696 + ], + "lines": [ + { + "bbox": [ + 106, + 629, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 106, + 629, + 505, + 642 + ], + "score": 1.0, + "content": "Several recent deep reinforcement learning works have used modular architectures and hierarchy", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 641, + 505, + 652 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 505, + 652 + ], + "score": 1.0, + "content": "to achieve generalization to new tasks. For example, Tessler et al. (2017) uses pre-trained skills", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 651, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 505, + 664 + ], + "score": 1.0, + "content": "for transfer. Oh et al. (2017) uses a meta-controller that selects parameterized skills and analogical", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 663, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 505, + 675 + ], + "score": 1.0, + "content": "supervision on outer-product structured tasks. Our assignments of attributes serves a similar purpose", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 674, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 674, + 505, + 685 + ], + "score": 1.0, + "content": "to their analogical supervision, and we use parameterized skills as these works do. However, our", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 685, + 408, + 696 + ], + "spans": [ + { + "bbox": [ + 106, + 685, + 408, + 696 + ], + "score": 1.0, + "content": "“meta-controller” is the search over attributes, rather than a reactive model.", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 48.5 + }, + { + "type": "text", + "bbox": [ + 107, + 702, + 504, + 724 + ], + "lines": [ + { + "bbox": [ + 105, + 701, + 504, + 714 + ], + "spans": [ + { + "bbox": [ + 105, + 701, + 504, + 714 + ], + "score": 1.0, + "content": "In Andreas et al. (2017), generalization is achieved through supervision in the form of “policy", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 712, + 505, + 725 + ], + "spans": [ + { + "bbox": [ + 105, + 712, + 505, + 725 + ], + "score": 1.0, + "content": "sketches”, which are symbolic representations of the high level steps necessary to complete a given", + "type": "text" + } + ], + "index": 53 + } + ], + "index": 52.5 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 759 + ], + "lines": [] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "As opposed to e.g. Kulkarni et al. (2016), where additional human supervision is used to allow ex-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 107 + ], + "score": 1.0, + "content": "ploration in the face of extremely sparse rewards, our goal is to show that adding human supervision", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 453, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 453, + 118 + ], + "score": 1.0, + "content": "to parameterize the task space via attributes allows compositionality through planning.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 105, + 82, + 505, + 118 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 121, + 505, + 209 + ], + "lines": [ + { + "bbox": [ + 105, + 120, + 505, + 133 + ], + "spans": [ + { + "bbox": [ + 105, + 120, + 505, + 133 + ], + "score": 1.0, + "content": "Horde and descendants Our work is related to generalized value functions (Sutton et al., 2011)", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 132, + 506, + 144 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 506, + 144 + ], + "score": 1.0, + "content": "in that we have policies parameterized by state and target attributes. In particular, if we used a", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 143, + 506, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 143, + 209, + 156 + ], + "score": 1.0, + "content": "parameterized model for", + "type": "text" + }, + { + "bbox": [ + 209, + 146, + 215, + 153 + ], + "score": 0.53, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 215, + 143, + 506, + 156 + ], + "score": 1.0, + "content": ", it would be similar to the factored state-goal representation in Schaul", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 154, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 505, + 167 + ], + "score": 1.0, + "content": "et al. (2015). Recently, van Seijen et al. (2017) used human provided attributes as a general value", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "score": 1.0, + "content": "function (GVF) in Ms. Pacman, showing that using a weighted combination of these can lead to", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 176, + 506, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 506, + 189 + ], + "score": 1.0, + "content": "higher scores than standard rewards. Although the representation used in that work is similar to", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "score": 1.0, + "content": "the one we use, the motivation in our work is to allow generalization to new tasks; and we use the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 392, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 392, + 211 + ], + "score": 1.0, + "content": "attributes to plan, rather than just as tools for building a reactive policy.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6.5, + "bbox_fs": [ + 105, + 120, + 506, + 211 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 214, + 505, + 313 + ], + "lines": [ + { + "bbox": [ + 106, + 215, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 106, + 215, + 505, + 227 + ], + "score": 1.0, + "content": "Factored MDP and Relational MDP Our approach is closely related to factored MDP (Boutilier", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 226, + 505, + 238 + ], + "spans": [ + { + "bbox": [ + 105, + 226, + 505, + 238 + ], + "score": 1.0, + "content": "et al., 1995; 2000; Guestrin et al., 2003b). In these works, it is assumed that the environment can", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 237, + 505, + 249 + ], + "spans": [ + { + "bbox": [ + 105, + 237, + 505, + 249 + ], + "score": 1.0, + "content": "be represented by discrete attributes, and that transitions between the attributes by an action can be", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 248, + 505, + 260 + ], + "spans": [ + { + "bbox": [ + 106, + 248, + 505, + 260 + ], + "score": 1.0, + "content": "modeled as a Bayesian network. The value of each attribute after an action is postulated to depend", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 258, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 258, + 505, + 271 + ], + "score": 1.0, + "content": "in a known way on attributes from before the action. The present work differs from these in that the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 270, + 505, + 283 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 505, + 283 + ], + "score": 1.0, + "content": "attributes do not determine the state and the dependency graph is not assumed to be known. More", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 281, + 506, + 294 + ], + "spans": [ + { + "bbox": [ + 105, + 281, + 506, + 294 + ], + "score": 1.0, + "content": "importantly, the focus in this work is on organizing the space of tasks through the attributes rather", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 291, + 505, + 305 + ], + "spans": [ + { + "bbox": [ + 105, + 291, + 505, + 305 + ], + "score": 1.0, + "content": "than being able to better plan a specific task; and in particular being able to generalize to new, more", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 303, + 214, + 315 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 214, + 315 + ], + "score": 1.0, + "content": "complex tasks at test time.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 215, + 506, + 315 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 319, + 505, + 418 + ], + "lines": [ + { + "bbox": [ + 105, + 320, + 505, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 505, + 332 + ], + "score": 1.0, + "content": "Our approach is also related to Relational MDP and Object Oriented MDP (Hernandez-Gardiol &", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 331, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 331, + 505, + 343 + ], + "score": 1.0, + "content": "Kaelbling, 2003; van Otterlo, 2005; Diuk et al., 2008; Abel et al., 2015), where states are described", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 342, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 342, + 505, + 353 + ], + "score": 1.0, + "content": "as a set of objects, each of which is an instantiation of canonical classes, and each instantiated object", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 353, + 505, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 505, + 365 + ], + "score": 1.0, + "content": "has a set of attributes. Our work is especially related to Guestrin et al. (2003a), where the aim is to", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 363, + 506, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 506, + 376 + ], + "score": 1.0, + "content": "show that by using a relational representation of an MDP, a policy from one domain can generalize", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 375, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 505, + 387 + ], + "score": 1.0, + "content": "to a new domain. However, in the current work, the attributes are taken directly as functions of the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 385, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 505, + 398 + ], + "score": 1.0, + "content": "state, as opposed to defined for object classes, and we do not have any explicit encoding of how", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 396, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 505, + 410 + ], + "score": 1.0, + "content": "objects interact. The model is given some examples of various attributes, and builds a parameterized", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 407, + 249, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 407, + 249, + 420 + ], + "score": 1.0, + "content": "model that maps into the attributes.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 24, + "bbox_fs": [ + 105, + 320, + 506, + 420 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 424, + 505, + 514 + ], + "lines": [ + { + "bbox": [ + 106, + 424, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 106, + 424, + 505, + 436 + ], + "score": 1.0, + "content": "The Programmable Agents of Denil et al. (2017) put the notions of objects and attributes (as in", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 436, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 436, + 505, + 447 + ], + "score": 1.0, + "content": "relational MDP) into an end-to-end differentiable neural architecture. Our work is similar to this", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 446, + 506, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 368, + 460 + ], + "score": 1.0, + "content": "one in that it includes learned mappings from states to attributes", + "type": "text" + }, + { + "bbox": [ + 368, + 446, + 376, + 459 + ], + "score": 0.72, + "content": "\\hat { f }", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 447, + 506, + 460 + ], + "score": 1.0, + "content": "in our work, detectors in theirs;", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 459, + 505, + 470 + ], + "spans": [ + { + "bbox": [ + 106, + 459, + 505, + 470 + ], + "score": 1.0, + "content": "although we do not learn these end-to-end), and experiments in the setting of manipulating blocks", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 470, + 505, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 505, + 482 + ], + "score": 1.0, + "content": "in a physics simulator. On the other hand, our model uses explicit search instead of an end-to-end", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 480, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 505, + 492 + ], + "score": 1.0, + "content": "neural architecture to reason over attributes. Moreover, in Denil et al. (2017), the agent is trained", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 492, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 505, + 504 + ], + "score": 1.0, + "content": "and tested on similar tasks, but the object properties at test are novel; whereas our model is trained", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 502, + 303, + 515 + ], + "spans": [ + { + "bbox": [ + 106, + 502, + 303, + 515 + ], + "score": 1.0, + "content": "on simple tasks but generalizes to complex ones.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 424, + 506, + 515 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 519, + 365, + 531 + ], + "lines": [ + { + "bbox": [ + 105, + 517, + 366, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 366, + 533 + ], + "score": 1.0, + "content": "Lifelong learning, multitask learning, and zero-shot learning", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 536, + 505, + 624 + ], + "lines": [ + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "score": 1.0, + "content": "There is a large literature on quickly adapting to a new learning problem given a set or a history", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 546, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 505, + 560 + ], + "score": 1.0, + "content": "of related learning problems. Our approach in this work shares ideas with the one in Isele et al.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 558, + 505, + 570 + ], + "spans": [ + { + "bbox": [ + 106, + 558, + 505, + 570 + ], + "score": 1.0, + "content": "(2016), where tasks are augmented with descriptors and featurized. Our attributes correspond to", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 570, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 570, + 505, + 581 + ], + "score": 1.0, + "content": "these features. In that work, the coefficients of the task features in a sparse dictionary are used to", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 580, + 504, + 591 + ], + "spans": [ + { + "bbox": [ + 106, + 580, + 504, + 591 + ], + "score": 1.0, + "content": "weight a set of vectors defining the model for the associated task. In our work, the low level actor", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 591, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 505, + 603 + ], + "score": 1.0, + "content": "takes in the task features, but we learn how to transit between sets of features, and plan in that space.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 601, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 601, + 505, + 614 + ], + "score": 1.0, + "content": "Similarly, the task is specified by a feature as an input into a model in Lopez-Paz & Ranzato (2017),", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 613, + 394, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 394, + 626 + ], + "score": 1.0, + "content": "again this corresponds to the way our low-level actor processes its goal.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 41.5, + "bbox_fs": [ + 105, + 536, + 505, + 626 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 630, + 505, + 696 + ], + "lines": [ + { + "bbox": [ + 106, + 629, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 106, + 629, + 505, + 642 + ], + "score": 1.0, + "content": "Several recent deep reinforcement learning works have used modular architectures and hierarchy", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 641, + 505, + 652 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 505, + 652 + ], + "score": 1.0, + "content": "to achieve generalization to new tasks. For example, Tessler et al. (2017) uses pre-trained skills", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 651, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 505, + 664 + ], + "score": 1.0, + "content": "for transfer. Oh et al. (2017) uses a meta-controller that selects parameterized skills and analogical", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 663, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 505, + 675 + ], + "score": 1.0, + "content": "supervision on outer-product structured tasks. Our assignments of attributes serves a similar purpose", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 674, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 674, + 505, + 685 + ], + "score": 1.0, + "content": "to their analogical supervision, and we use parameterized skills as these works do. However, our", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 685, + 408, + 696 + ], + "spans": [ + { + "bbox": [ + 106, + 685, + 408, + 696 + ], + "score": 1.0, + "content": "“meta-controller” is the search over attributes, rather than a reactive model.", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 48.5, + "bbox_fs": [ + 105, + 629, + 505, + 696 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 702, + 504, + 724 + ], + "lines": [ + { + "bbox": [ + 105, + 701, + 504, + 714 + ], + "spans": [ + { + "bbox": [ + 105, + 701, + 504, + 714 + ], + "score": 1.0, + "content": "In Andreas et al. (2017), generalization is achieved through supervision in the form of “policy", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 712, + 505, + 725 + ], + "spans": [ + { + "bbox": [ + 105, + 712, + 505, + 725 + ], + "score": 1.0, + "content": "sketches”, which are symbolic representations of the high level steps necessary to complete a given", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 106, + 83, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 506, + 95 + ], + "score": 1.0, + "content": "task. The low level steps in executing modules in the sketches are composable. Our work is similar", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "score": 1.0, + "content": "in that high level annotation is used to enable generalization, but the mechanism in this work is", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "score": 1.0, + "content": "different. Note that the approaches in Andreas et al. (2017); Oh et al. (2017) are complementary to", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 408, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 408, + 128 + ], + "score": 1.0, + "content": "the one described here; in future work we wish to explore combining them.", + "type": "text", + "cross_page": true + } + ], + "index": 3 + } + ], + "index": 52.5, + "bbox_fs": [ + 105, + 701, + 505, + 725 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 126 + ], + "lines": [ + { + "bbox": [ + 106, + 83, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 506, + 95 + ], + "score": 1.0, + "content": "task. The low level steps in executing modules in the sketches are composable. Our work is similar", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "score": 1.0, + "content": "in that high level annotation is used to enable generalization, but the mechanism in this work is", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "score": 1.0, + "content": "different. Note that the approaches in Andreas et al. (2017); Oh et al. (2017) are complementary to", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 408, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 408, + 128 + ], + "score": 1.0, + "content": "the one described here; in future work we wish to explore combining them.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "text", + "bbox": [ + 106, + 132, + 505, + 198 + ], + "lines": [ + { + "bbox": [ + 106, + 132, + 505, + 145 + ], + "spans": [ + { + "bbox": [ + 106, + 132, + 505, + 145 + ], + "score": 1.0, + "content": "Semiparametric methods In this work we use an explicit memory of sets of attributes the model", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 144, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 106, + 144, + 505, + 155 + ], + "score": 1.0, + "content": "has seen. Several previous works have used non-parametric memories for lowering the sample", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 154, + 506, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 154, + 506, + 167 + ], + "score": 1.0, + "content": "complexity of learning, e.g. Blundell et al. (2016); Pritzel et al. (2017). Like these, we lean on", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "score": 1.0, + "content": "the fact that with a good representation of a state, it can be useful to memorize what to do in given", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 176, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 505, + 189 + ], + "score": 1.0, + "content": "situation (having only done it a small number of times) and explicitly look it up. In our case, the", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 107, + 187, + 372, + 200 + ], + "spans": [ + { + "bbox": [ + 107, + 187, + 372, + 200 + ], + "score": 1.0, + "content": "“good representation” is informed by the user-specified attributes.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 107, + 204, + 504, + 248 + ], + "lines": [ + { + "bbox": [ + 106, + 204, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 106, + 204, + 505, + 216 + ], + "score": 1.0, + "content": "Our approach is also related to Machado et al. (2017), which builds up a multiscale representation", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 214, + 506, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 506, + 227 + ], + "score": 1.0, + "content": "of an MDP using Eigenvectors of the transition matrix of the MDP, in the sense that we collect data", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 227, + 506, + 238 + ], + "spans": [ + { + "bbox": [ + 105, + 227, + 506, + 238 + ], + "score": 1.0, + "content": "on possible transitions between attributes in a first phase of training, and then use this knowledge at", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 237, + 146, + 249 + ], + "spans": [ + { + "bbox": [ + 105, + 237, + 146, + 249 + ], + "score": 1.0, + "content": "test time.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 107, + 253, + 505, + 320 + ], + "lines": [ + { + "bbox": [ + 105, + 253, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 505, + 266 + ], + "score": 1.0, + "content": "Attributes in vision Farhadi et al. (2009) and Lampert et al. (2009) explore visual attributes as", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 266, + 504, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 266, + 504, + 277 + ], + "score": 1.0, + "content": "a natural intermediate representation for object recognition tasks, demonstrating their effective-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 275, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 505, + 288 + ], + "score": 1.0, + "content": "ness in one/low-shot settings. Subsequent work has applied the concept to fine-grained recogni-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 286, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 505, + 299 + ], + "score": 1.0, + "content": "tion (Duan et al., 2012), people’s appearance/clothing (Zhang et al., 2014) and relative judgements", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 297, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 505, + 310 + ], + "score": 1.0, + "content": "(Parikh & Grauman, 2011). However, all these are static I.I.D settings, in contrast to dynamic", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 309, + 280, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 280, + 321 + ], + "score": 1.0, + "content": "agent/environment that this work explores.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 16.5 + }, + { + "type": "title", + "bbox": [ + 108, + 335, + 200, + 348 + ], + "lines": [ + { + "bbox": [ + 105, + 334, + 201, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 201, + 350 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 360, + 504, + 405 + ], + "lines": [ + { + "bbox": [ + 105, + 360, + 506, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 355, + 373 + ], + "score": 1.0, + "content": "We evaluate our approach (Attribute Planner, abbreviated to", + "type": "text" + }, + { + "bbox": [ + 355, + 361, + 370, + 371 + ], + "score": 0.7, + "content": "A P", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 360, + 506, + 373 + ], + "score": 1.0, + "content": ") in three different environments.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 371, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 106, + 371, + 505, + 383 + ], + "score": 1.0, + "content": "The first two are randomly generated grid-worlds, and the third is a simulation of stacking blocks.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 382, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 382, + 505, + 394 + ], + "score": 1.0, + "content": "In each environment, the goal of the model is to be able to generalize to testing on complex tasks", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 393, + 231, + 405 + ], + "spans": [ + { + "bbox": [ + 106, + 393, + 231, + 405 + ], + "score": 1.0, + "content": "from training on simpler tasks.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 108, + 410, + 504, + 443 + ], + "lines": [ + { + "bbox": [ + 106, + 409, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 106, + 409, + 505, + 423 + ], + "score": 1.0, + "content": "We compare against baseline policies trained in several ways. These baseline policies take the state", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 421, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 505, + 433 + ], + "score": 1.0, + "content": "and goal as inputs, and use the same neural network architecture as the policy used for the Attribute", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 432, + 142, + 444 + ], + "spans": [ + { + "bbox": [ + 105, + 432, + 142, + 444 + ], + "score": 1.0, + "content": "Planner.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 130, + 451, + 504, + 565 + ], + "lines": [ + { + "bbox": [ + 129, + 452, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 129, + 452, + 505, + 464 + ], + "score": 1.0, + "content": "1. Reinforcement Learning: Policies trained via reinforcement learning with A3C (Mnih", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 141, + 462, + 506, + 475 + ], + "spans": [ + { + "bbox": [ + 141, + 462, + 506, + 475 + ], + "score": 1.0, + "content": "et al., 2016) or Reinforce. We consider three variants of training: (i) training only with", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 142, + 474, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 142, + 474, + 505, + 486 + ], + "score": 1.0, + "content": "nearby goals (one attribute transition for grid-world; single actions for block stacking); (ii)", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 142, + 485, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 142, + 485, + 505, + 497 + ], + "score": 1.0, + "content": "training on the evaluation tasks; and (iii) training on a curriculum that transitions from", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 141, + 496, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 141, + 496, + 505, + 509 + ], + "score": 1.0, + "content": "nearby goals to evaluation tasks. Policies (ii) and (iii) are trained on full sequences, thus", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 140, + 505, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 140, + 505, + 505, + 520 + ], + "score": 1.0, + "content": "have an inherent advantage over our model, which only sees short sequences during train-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 141, + 518, + 161, + 532 + ], + "spans": [ + { + "bbox": [ + 141, + 518, + 161, + 532 + ], + "score": 1.0, + "content": "ing.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 130, + 531, + 506, + 544 + ], + "spans": [ + { + "bbox": [ + 130, + 531, + 506, + 544 + ], + "score": 1.0, + "content": "2. Inverse: An inverse model trained in a “supervised” fashion on a dataset of observed", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 141, + 543, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 141, + 543, + 505, + 555 + ], + "score": 1.0, + "content": "trajectories to predict the next action given the state and goal. We train on nearby goals and", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 142, + 555, + 250, + 567 + ], + "spans": [ + { + "bbox": [ + 142, + 555, + 250, + 567 + ], + "score": 1.0, + "content": "on longer multi-step tasks.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 32.5 + }, + { + "type": "title", + "bbox": [ + 107, + 578, + 189, + 589 + ], + "lines": [ + { + "bbox": [ + 105, + 577, + 190, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 190, + 591 + ], + "score": 1.0, + "content": "4.1 2-D WORLDS", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 108, + 599, + 504, + 632 + ], + "lines": [ + { + "bbox": [ + 106, + 599, + 506, + 612 + ], + "spans": [ + { + "bbox": [ + 106, + 599, + 258, + 612 + ], + "score": 1.0, + "content": "We implemented two types of small 2-", + "type": "text" + }, + { + "bbox": [ + 258, + 600, + 268, + 609 + ], + "score": 0.39, + "content": ". D", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 599, + 506, + 612 + ], + "score": 1.0, + "content": "environments in Mazebase (Sukhbaatar et al., 2015), where", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 610, + 506, + 622 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 506, + 622 + ], + "score": 1.0, + "content": "the worlds are randomly generated for each episode. The action space for each consists of move-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 621, + 433, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 621, + 433, + 633 + ], + "score": 1.0, + "content": "ments in the four cardinal directions, and additional environment specific actions.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 108, + 638, + 504, + 693 + ], + "lines": [ + { + "bbox": [ + 106, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "Colored Switches The first environment consists of four switches, each with four possible colors.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 648, + 506, + 662 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 506, + 662 + ], + "score": 1.0, + "content": "An extra toggle action cycles the color of a switch if the agent is standing on it. The attributes", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "for this environment are the states of the switches; and the tasks are to change the switches into", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 671, + 506, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 506, + 684 + ], + "score": 1.0, + "content": "a specified configuration, as shown in Fig. 2(right). The locations and colors of the switches are", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 682, + 259, + 694 + ], + "spans": [ + { + "bbox": [ + 106, + 682, + 259, + 694 + ], + "score": 1.0, + "content": "randomly initialized for each episode.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 44 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "Crafting In the second environment, similar to the one used in Andreas et al. (2017) an agent", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 709, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 721 + ], + "score": 1.0, + "content": "needs to collect resources and combine them to form items. In addition to moving in the cardinal", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 721, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 505, + 733 + ], + "score": 1.0, + "content": "directions, the agent has a “grab” action that allows it to pick up a resource from the current location", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 48 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 126 + ], + "lines": [], + "index": 1.5, + "bbox_fs": [ + 105, + 83, + 506, + 128 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 132, + 505, + 198 + ], + "lines": [ + { + "bbox": [ + 106, + 132, + 505, + 145 + ], + "spans": [ + { + "bbox": [ + 106, + 132, + 505, + 145 + ], + "score": 1.0, + "content": "Semiparametric methods In this work we use an explicit memory of sets of attributes the model", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 144, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 106, + 144, + 505, + 155 + ], + "score": 1.0, + "content": "has seen. Several previous works have used non-parametric memories for lowering the sample", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 154, + 506, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 154, + 506, + 167 + ], + "score": 1.0, + "content": "complexity of learning, e.g. Blundell et al. (2016); Pritzel et al. (2017). Like these, we lean on", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "score": 1.0, + "content": "the fact that with a good representation of a state, it can be useful to memorize what to do in given", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 176, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 505, + 189 + ], + "score": 1.0, + "content": "situation (having only done it a small number of times) and explicitly look it up. In our case, the", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 107, + 187, + 372, + 200 + ], + "spans": [ + { + "bbox": [ + 107, + 187, + 372, + 200 + ], + "score": 1.0, + "content": "“good representation” is informed by the user-specified attributes.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6.5, + "bbox_fs": [ + 105, + 132, + 506, + 200 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 204, + 504, + 248 + ], + "lines": [ + { + "bbox": [ + 106, + 204, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 106, + 204, + 505, + 216 + ], + "score": 1.0, + "content": "Our approach is also related to Machado et al. (2017), which builds up a multiscale representation", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 214, + 506, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 506, + 227 + ], + "score": 1.0, + "content": "of an MDP using Eigenvectors of the transition matrix of the MDP, in the sense that we collect data", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 227, + 506, + 238 + ], + "spans": [ + { + "bbox": [ + 105, + 227, + 506, + 238 + ], + "score": 1.0, + "content": "on possible transitions between attributes in a first phase of training, and then use this knowledge at", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 237, + 146, + 249 + ], + "spans": [ + { + "bbox": [ + 105, + 237, + 146, + 249 + ], + "score": 1.0, + "content": "test time.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 204, + 506, + 249 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 253, + 505, + 320 + ], + "lines": [ + { + "bbox": [ + 105, + 253, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 505, + 266 + ], + "score": 1.0, + "content": "Attributes in vision Farhadi et al. (2009) and Lampert et al. (2009) explore visual attributes as", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 266, + 504, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 266, + 504, + 277 + ], + "score": 1.0, + "content": "a natural intermediate representation for object recognition tasks, demonstrating their effective-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 275, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 505, + 288 + ], + "score": 1.0, + "content": "ness in one/low-shot settings. Subsequent work has applied the concept to fine-grained recogni-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 286, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 505, + 299 + ], + "score": 1.0, + "content": "tion (Duan et al., 2012), people’s appearance/clothing (Zhang et al., 2014) and relative judgements", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 297, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 505, + 310 + ], + "score": 1.0, + "content": "(Parikh & Grauman, 2011). However, all these are static I.I.D settings, in contrast to dynamic", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 309, + 280, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 280, + 321 + ], + "score": 1.0, + "content": "agent/environment that this work explores.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 16.5, + "bbox_fs": [ + 105, + 253, + 505, + 321 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 335, + 200, + 348 + ], + "lines": [ + { + "bbox": [ + 105, + 334, + 201, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 201, + 350 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 360, + 504, + 405 + ], + "lines": [ + { + "bbox": [ + 105, + 360, + 506, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 355, + 373 + ], + "score": 1.0, + "content": "We evaluate our approach (Attribute Planner, abbreviated to", + "type": "text" + }, + { + "bbox": [ + 355, + 361, + 370, + 371 + ], + "score": 0.7, + "content": "A P", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 360, + 506, + 373 + ], + "score": 1.0, + "content": ") in three different environments.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 371, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 106, + 371, + 505, + 383 + ], + "score": 1.0, + "content": "The first two are randomly generated grid-worlds, and the third is a simulation of stacking blocks.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 382, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 382, + 505, + 394 + ], + "score": 1.0, + "content": "In each environment, the goal of the model is to be able to generalize to testing on complex tasks", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 393, + 231, + 405 + ], + "spans": [ + { + "bbox": [ + 106, + 393, + 231, + 405 + ], + "score": 1.0, + "content": "from training on simpler tasks.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 360, + 506, + 405 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 410, + 504, + 443 + ], + "lines": [ + { + "bbox": [ + 106, + 409, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 106, + 409, + 505, + 423 + ], + "score": 1.0, + "content": "We compare against baseline policies trained in several ways. These baseline policies take the state", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 421, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 505, + 433 + ], + "score": 1.0, + "content": "and goal as inputs, and use the same neural network architecture as the policy used for the Attribute", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 432, + 142, + 444 + ], + "spans": [ + { + "bbox": [ + 105, + 432, + 142, + 444 + ], + "score": 1.0, + "content": "Planner.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26, + "bbox_fs": [ + 105, + 409, + 505, + 444 + ] + }, + { + "type": "list", + "bbox": [ + 130, + 451, + 504, + 565 + ], + "lines": [ + { + "bbox": [ + 129, + 452, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 129, + 452, + 505, + 464 + ], + "score": 1.0, + "content": "1. Reinforcement Learning: Policies trained via reinforcement learning with A3C (Mnih", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 462, + 506, + 475 + ], + "spans": [ + { + "bbox": [ + 141, + 462, + 506, + 475 + ], + "score": 1.0, + "content": "et al., 2016) or Reinforce. We consider three variants of training: (i) training only with", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 142, + 474, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 142, + 474, + 505, + 486 + ], + "score": 1.0, + "content": "nearby goals (one attribute transition for grid-world; single actions for block stacking); (ii)", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 142, + 485, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 142, + 485, + 505, + 497 + ], + "score": 1.0, + "content": "training on the evaluation tasks; and (iii) training on a curriculum that transitions from", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 141, + 496, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 141, + 496, + 505, + 509 + ], + "score": 1.0, + "content": "nearby goals to evaluation tasks. Policies (ii) and (iii) are trained on full sequences, thus", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 140, + 505, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 140, + 505, + 505, + 520 + ], + "score": 1.0, + "content": "have an inherent advantage over our model, which only sees short sequences during train-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 141, + 518, + 161, + 532 + ], + "spans": [ + { + "bbox": [ + 141, + 518, + 161, + 532 + ], + "score": 1.0, + "content": "ing.", + "type": "text" + } + ], + "index": 34, + "is_list_end_line": true + }, + { + "bbox": [ + 130, + 531, + 506, + 544 + ], + "spans": [ + { + "bbox": [ + 130, + 531, + 506, + 544 + ], + "score": 1.0, + "content": "2. Inverse: An inverse model trained in a “supervised” fashion on a dataset of observed", + "type": "text" + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 543, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 141, + 543, + 505, + 555 + ], + "score": 1.0, + "content": "trajectories to predict the next action given the state and goal. We train on nearby goals and", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 142, + 555, + 250, + 567 + ], + "spans": [ + { + "bbox": [ + 142, + 555, + 250, + 567 + ], + "score": 1.0, + "content": "on longer multi-step tasks.", + "type": "text" + } + ], + "index": 37, + "is_list_end_line": true + } + ], + "index": 32.5, + "bbox_fs": [ + 129, + 452, + 506, + 567 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 578, + 189, + 589 + ], + "lines": [ + { + "bbox": [ + 105, + 577, + 190, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 190, + 591 + ], + "score": 1.0, + "content": "4.1 2-D WORLDS", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 108, + 599, + 504, + 632 + ], + "lines": [ + { + "bbox": [ + 106, + 599, + 506, + 612 + ], + "spans": [ + { + "bbox": [ + 106, + 599, + 258, + 612 + ], + "score": 1.0, + "content": "We implemented two types of small 2-", + "type": "text" + }, + { + "bbox": [ + 258, + 600, + 268, + 609 + ], + "score": 0.39, + "content": ". D", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 599, + 506, + 612 + ], + "score": 1.0, + "content": "environments in Mazebase (Sukhbaatar et al., 2015), where", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 610, + 506, + 622 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 506, + 622 + ], + "score": 1.0, + "content": "the worlds are randomly generated for each episode. The action space for each consists of move-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 621, + 433, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 621, + 433, + 633 + ], + "score": 1.0, + "content": "ments in the four cardinal directions, and additional environment specific actions.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40, + "bbox_fs": [ + 106, + 599, + 506, + 633 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 638, + 504, + 693 + ], + "lines": [ + { + "bbox": [ + 106, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "Colored Switches The first environment consists of four switches, each with four possible colors.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 648, + 506, + 662 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 506, + 662 + ], + "score": 1.0, + "content": "An extra toggle action cycles the color of a switch if the agent is standing on it. The attributes", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "for this environment are the states of the switches; and the tasks are to change the switches into", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 671, + 506, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 506, + 684 + ], + "score": 1.0, + "content": "a specified configuration, as shown in Fig. 2(right). The locations and colors of the switches are", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 682, + 259, + 694 + ], + "spans": [ + { + "bbox": [ + 106, + 682, + 259, + 694 + ], + "score": 1.0, + "content": "randomly initialized for each episode.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 44, + "bbox_fs": [ + 105, + 637, + 506, + 694 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "Crafting In the second environment, similar to the one used in Andreas et al. (2017) an agent", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 709, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 721 + ], + "score": 1.0, + "content": "needs to collect resources and combine them to form items. In addition to moving in the cardinal", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 721, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 505, + 733 + ], + "score": 1.0, + "content": "directions, the agent has a “grab” action that allows it to pick up a resource from the current location", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "and add it to its inventory. If there is no item where the agent is standing, this action does nothing.", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "score": 1.0, + "content": "The agent also has a “craft” action that combines a set of items to create a new item if the agent", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 506, + 118 + ], + "score": 1.0, + "content": "has the prerequisite items in its inventory and the agent is standing on a special square (a “crafting", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 505, + 127 + ], + "score": 1.0, + "content": "table”) corresponding to the item to be crafted. If these two conditions are not both met, the “craft”", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 127, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 106, + 127, + 505, + 138 + ], + "score": 1.0, + "content": "action does nothing. The attributes for this environment are the items in the inventory, and task is", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 137, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 505, + 150 + ], + "score": 1.0, + "content": "to add a specified item to the inventory. In the environment, there are three types of resources and", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 148, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 505, + 161 + ], + "score": 1.0, + "content": "three types of products (see Fig. 2(left)). The episodes are initialized randomly by removing some", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 310, + 172 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 310, + 172 + ], + "score": 1.0, + "content": "resources, and adding some items to the inventory.", + "type": "text", + "cross_page": true + } + ], + "index": 7 + } + ], + "index": 48, + "bbox_fs": [ + 105, + 699, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 505, + 171 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "and add it to its inventory. If there is no item where the agent is standing, this action does nothing.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "score": 1.0, + "content": "The agent also has a “craft” action that combines a set of items to create a new item if the agent", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 506, + 118 + ], + "score": 1.0, + "content": "has the prerequisite items in its inventory and the agent is standing on a special square (a “crafting", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 505, + 127 + ], + "score": 1.0, + "content": "table”) corresponding to the item to be crafted. If these two conditions are not both met, the “craft”", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 127, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 106, + 127, + 505, + 138 + ], + "score": 1.0, + "content": "action does nothing. The attributes for this environment are the items in the inventory, and task is", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 137, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 505, + 150 + ], + "score": 1.0, + "content": "to add a specified item to the inventory. In the environment, there are three types of resources and", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 148, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 505, + 161 + ], + "score": 1.0, + "content": "three types of products (see Fig. 2(left)). The episodes are initialized randomly by removing some", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 310, + 172 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 310, + 172 + ], + "score": 1.0, + "content": "resources, and adding some items to the inventory.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 3.5 + }, + { + "type": "image", + "bbox": [ + 148, + 185, + 459, + 273 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 148, + 185, + 459, + 273 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 148, + 185, + 459, + 273 + ], + "spans": [ + { + "bbox": [ + 148, + 185, + 459, + 273 + ], + "score": 0.97, + "type": "image", + "image_path": "90bf30f100a426d3873f3b1558a4c751c1d2761eee1695cfb6bb790c71fe9f95.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 148, + 185, + 459, + 214.33333333333334 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 148, + 214.33333333333334, + 459, + 243.66666666666669 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 148, + 243.66666666666669, + 459, + 273.0 + ], + "spans": [], + "index": 10 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 117, + 276, + 490, + 287 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 118, + 274, + 492, + 288 + ], + "spans": [ + { + "bbox": [ + 118, + 274, + 492, + 288 + ], + "score": 1.0, + "content": "! + ! = + + ! =+ + ! =Figure 2: Left: Crafting mazebase game. Right: Colored switches game. See text for details.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + } + ], + "index": 10.0 + }, + { + "type": "text", + "bbox": [ + 106, + 297, + 505, + 341 + ], + "lines": [ + { + "bbox": [ + 105, + 296, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 505, + 310 + ], + "score": 1.0, + "content": "1 1The observation is given as a bag of words in both environments, where the words correspond to", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 308, + 505, + 320 + ], + "spans": [ + { + "bbox": [ + 106, + 308, + 505, + 320 + ], + "score": 1.0, + "content": "(feature, location). Features consist of item types, names, and their other properties. The locations", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 318, + 506, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 506, + 332 + ], + "score": 1.0, + "content": "1include position relative to the agent in the maze, and also a few special slots for inventory, current,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 330, + 191, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 330, + 191, + 343 + ], + "score": 1.0, + "content": "and target attributes.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 106, + 347, + 505, + 457 + ], + "lines": [ + { + "bbox": [ + 106, + 347, + 505, + 359 + ], + "spans": [ + { + "bbox": [ + 106, + 347, + 505, + 359 + ], + "score": 1.0, + "content": "The first phase building the high level transitions as in Section 2.1.2 is done by running a random", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 357, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 357, + 505, + 371 + ], + "score": 1.0, + "content": "1 1agent in the environment from a random state until one or more attributes change. Then this change", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 369, + 506, + 381 + ], + "spans": [ + { + "bbox": [ + 105, + 369, + 279, + 381 + ], + "score": 1.0, + "content": "of attribute is recorded as an edge in graph", + "type": "text" + }, + { + "bbox": [ + 280, + 369, + 289, + 379 + ], + "score": 0.68, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 369, + 506, + 381 + ], + "score": 1.0, + "content": ". The low level policy is trained concurrently with the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 380, + 505, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 505, + 393 + ], + "score": 1.0, + "content": "second phase of Section 2.1.2. We use the current edge estimates in the graph to propose a target", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 391, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 391, + 505, + 403 + ], + "score": 1.0, + "content": "set of attributes, and the low level policy is trained with the Reinforce algorithm (Williams, 1992)", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 401, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 505, + 414 + ], + "score": 1.0, + "content": "to reach that set of attributes from the current state. These training episodes terminate when the task", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 413, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 506, + 426 + ], + "score": 1.0, + "content": "completes or after 80 steps; and a reward of -0.1 is given at every step to encourage the agent to", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 424, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 106, + 424, + 505, + 436 + ], + "score": 1.0, + "content": "complete the task quickly. The policy network is a fully connected network with two hidden layers", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 434, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 505, + 447 + ], + "score": 1.0, + "content": "of 100 units. We run each experiment three times with different random seeds, and report the mean", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 447, + 159, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 447, + 159, + 457 + ], + "score": 1.0, + "content": "success rate.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 107, + 462, + 505, + 529 + ], + "lines": [ + { + "bbox": [ + 105, + 462, + 506, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 506, + 475 + ], + "score": 1.0, + "content": "In the switches environment, multi-step (test) tasks are generated by setting a random attribute as", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 473, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 505, + 486 + ], + "score": 1.0, + "content": "target, which can require up to 12 attribute transitions. In the crafting environment, multi-step (test)", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 485, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 106, + 485, + 505, + 497 + ], + "score": 1.0, + "content": "tasks are generated by randomly selecting an item as a target. Since we do not care about other items", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 495, + 505, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 505, + 508 + ], + "score": 1.0, + "content": "in the inventory, the target state is underspecified. Some tasks are pre-solved because the randomly", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 506, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 505, + 520 + ], + "score": 1.0, + "content": "chosen target item can already be in the inventory. However, such tasks have no effect on training", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 517, + 253, + 531 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 253, + 531 + ], + "score": 1.0, + "content": "and are also removed during testing.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 106, + 534, + 505, + 579 + ], + "lines": [ + { + "bbox": [ + 106, + 534, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 106, + 534, + 505, + 546 + ], + "score": 1.0, + "content": "In curriculum training which we use as a baseline, we gradually increase the upper bound on the", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "score": 1.0, + "content": "difficulty of tasks. In the switches environment, the difficulty corresponds to the number of toggles", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 557, + 504, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 557, + 504, + 569 + ], + "score": 1.0, + "content": "necessary for solving the task. The craft environment has two levels of difficulty: tasks can be", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 567, + 455, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 455, + 580 + ], + "score": 1.0, + "content": "completed by a single grab or craft action, and tasks that require multiple such actions.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33.5 + }, + { + "type": "text", + "bbox": [ + 106, + 584, + 504, + 607 + ], + "lines": [ + { + "bbox": [ + 105, + 582, + 504, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 462, + 599 + ], + "score": 1.0, + "content": "During the second phase of training, we simultaneously compute the transition function", + "type": "text" + }, + { + "bbox": [ + 463, + 584, + 504, + 597 + ], + "score": 0.91, + "content": "c _ { \\pi } ( \\rho _ { i } , \\rho _ { j } )", + "type": "inline_equation" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 595, + 438, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 426, + 608 + ], + "score": 1.0, + "content": "using an exponentially decaying average of success rates of the low level policy", + "type": "text" + }, + { + "bbox": [ + 426, + 597, + 434, + 605 + ], + "score": 0.75, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 595, + 438, + 608 + ], + "score": 1.0, + "content": ":", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5 + }, + { + "type": "interline_equation", + "bbox": [ + 229, + 617, + 381, + 650 + ], + "lines": [ + { + "bbox": [ + 229, + 617, + 381, + 650 + ], + "spans": [ + { + "bbox": [ + 229, + 617, + 381, + 650 + ], + "score": 0.95, + "content": "c _ { \\pi } ( \\rho _ { i } , \\rho _ { j } ) = \\frac { \\sum _ { t = 1 } ^ { T } \\gamma ^ { T - t } M _ { \\pi } ^ { t } ( \\rho _ { i } , \\rho _ { j } ) } { \\sum _ { t = 1 } ^ { T } \\gamma ^ { T - t } N _ { \\pi } ^ { t } ( \\rho _ { i } , \\rho _ { j } ) } ,", + "type": "interline_equation", + "image_path": "77129c3880f0194beedf8e4e4d006ca6fc8f5bfcd1a0b98c75d6b36bad52d10f.jpg" + } + ] + } + ], + "index": 38.5, + "virtual_lines": [ + { + "bbox": [ + 229, + 617, + 381, + 633.5 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 229, + 633.5, + 381, + 650.0 + ], + "spans": [], + "index": 39 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 659, + 503, + 682 + ], + "lines": [ + { + "bbox": [ + 105, + 658, + 503, + 674 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 133, + 674 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 660, + 141, + 670 + ], + "score": 0.8, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 658, + 275, + 674 + ], + "score": 1.0, + "content": "is the number of training epochs,", + "type": "text" + }, + { + "bbox": [ + 275, + 660, + 289, + 672 + ], + "score": 0.9, + "content": "N _ { \\pi } ^ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 658, + 376, + 674 + ], + "score": 1.0, + "content": "is the number of task", + "type": "text" + }, + { + "bbox": [ + 376, + 660, + 407, + 672 + ], + "score": 0.92, + "content": "( \\rho _ { i } , \\rho _ { j } )", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 658, + 462, + 674 + ], + "score": 1.0, + "content": "during epoch", + "type": "text" + }, + { + "bbox": [ + 462, + 661, + 467, + 670 + ], + "score": 0.75, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 468, + 658, + 487, + 674 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 488, + 660, + 503, + 672 + ], + "score": 0.9, + "content": "M _ { \\pi } ^ { t }", + "type": "inline_equation" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 671, + 439, + 682 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 373, + 682 + ], + "score": 1.0, + "content": "is the number of successful episodes among them. A decay rate of", + "type": "text" + }, + { + "bbox": [ + 373, + 672, + 406, + 682 + ], + "score": 0.89, + "content": "\\gamma = 0 . 9", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 671, + 439, + 682 + ], + "score": 1.0, + "content": "is used.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 688, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 505, + 699 + ], + "score": 1.0, + "content": "Table 1 compares our Attribute Planner (AP) model to a Reinforce baseline on the Crafting and", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "Colored Switches tasks. In all cases, the baseline performs poorly, while the AP model has a high", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "success rate. The importance of the graph is apparent: when it is removed (Reinforce method) the", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 721, + 316, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 316, + 733 + ], + "score": 1.0, + "content": "performance drops significantly on multi-step tasks.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43.5 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 505, + 171 + ], + "lines": [], + "index": 3.5, + "bbox_fs": [ + 105, + 81, + 506, + 172 + ], + "lines_deleted": true + }, + { + "type": "image", + "bbox": [ + 148, + 185, + 459, + 273 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 148, + 185, + 459, + 273 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 148, + 185, + 459, + 273 + ], + "spans": [ + { + "bbox": [ + 148, + 185, + 459, + 273 + ], + "score": 0.97, + "type": "image", + "image_path": "90bf30f100a426d3873f3b1558a4c751c1d2761eee1695cfb6bb790c71fe9f95.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 148, + 185, + 459, + 214.33333333333334 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 148, + 214.33333333333334, + 459, + 243.66666666666669 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 148, + 243.66666666666669, + 459, + 273.0 + ], + "spans": [], + "index": 10 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 117, + 276, + 490, + 287 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 118, + 274, + 492, + 288 + ], + "spans": [ + { + "bbox": [ + 118, + 274, + 492, + 288 + ], + "score": 1.0, + "content": "! + ! = + + ! =+ + ! =Figure 2: Left: Crafting mazebase game. Right: Colored switches game. See text for details.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + } + ], + "index": 10.0 + }, + { + "type": "text", + "bbox": [ + 106, + 297, + 505, + 341 + ], + "lines": [ + { + "bbox": [ + 105, + 296, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 505, + 310 + ], + "score": 1.0, + "content": "1 1The observation is given as a bag of words in both environments, where the words correspond to", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 308, + 505, + 320 + ], + "spans": [ + { + "bbox": [ + 106, + 308, + 505, + 320 + ], + "score": 1.0, + "content": "(feature, location). Features consist of item types, names, and their other properties. The locations", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 318, + 506, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 506, + 332 + ], + "score": 1.0, + "content": "1include position relative to the agent in the maze, and also a few special slots for inventory, current,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 330, + 191, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 330, + 191, + 343 + ], + "score": 1.0, + "content": "and target attributes.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13.5, + "bbox_fs": [ + 105, + 296, + 506, + 343 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 347, + 505, + 457 + ], + "lines": [ + { + "bbox": [ + 106, + 347, + 505, + 359 + ], + "spans": [ + { + "bbox": [ + 106, + 347, + 505, + 359 + ], + "score": 1.0, + "content": "The first phase building the high level transitions as in Section 2.1.2 is done by running a random", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 357, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 357, + 505, + 371 + ], + "score": 1.0, + "content": "1 1agent in the environment from a random state until one or more attributes change. Then this change", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 369, + 506, + 381 + ], + "spans": [ + { + "bbox": [ + 105, + 369, + 279, + 381 + ], + "score": 1.0, + "content": "of attribute is recorded as an edge in graph", + "type": "text" + }, + { + "bbox": [ + 280, + 369, + 289, + 379 + ], + "score": 0.68, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 369, + 506, + 381 + ], + "score": 1.0, + "content": ". The low level policy is trained concurrently with the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 380, + 505, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 505, + 393 + ], + "score": 1.0, + "content": "second phase of Section 2.1.2. We use the current edge estimates in the graph to propose a target", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 391, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 391, + 505, + 403 + ], + "score": 1.0, + "content": "set of attributes, and the low level policy is trained with the Reinforce algorithm (Williams, 1992)", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 401, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 505, + 414 + ], + "score": 1.0, + "content": "to reach that set of attributes from the current state. These training episodes terminate when the task", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 413, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 506, + 426 + ], + "score": 1.0, + "content": "completes or after 80 steps; and a reward of -0.1 is given at every step to encourage the agent to", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 424, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 106, + 424, + 505, + 436 + ], + "score": 1.0, + "content": "complete the task quickly. The policy network is a fully connected network with two hidden layers", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 434, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 505, + 447 + ], + "score": 1.0, + "content": "of 100 units. We run each experiment three times with different random seeds, and report the mean", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 447, + 159, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 447, + 159, + 457 + ], + "score": 1.0, + "content": "success rate.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 20.5, + "bbox_fs": [ + 105, + 347, + 506, + 457 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 462, + 505, + 529 + ], + "lines": [ + { + "bbox": [ + 105, + 462, + 506, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 506, + 475 + ], + "score": 1.0, + "content": "In the switches environment, multi-step (test) tasks are generated by setting a random attribute as", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 473, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 505, + 486 + ], + "score": 1.0, + "content": "target, which can require up to 12 attribute transitions. In the crafting environment, multi-step (test)", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 485, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 106, + 485, + 505, + 497 + ], + "score": 1.0, + "content": "tasks are generated by randomly selecting an item as a target. Since we do not care about other items", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 495, + 505, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 505, + 508 + ], + "score": 1.0, + "content": "in the inventory, the target state is underspecified. Some tasks are pre-solved because the randomly", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 506, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 505, + 520 + ], + "score": 1.0, + "content": "chosen target item can already be in the inventory. However, such tasks have no effect on training", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 517, + 253, + 531 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 253, + 531 + ], + "score": 1.0, + "content": "and are also removed during testing.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 28.5, + "bbox_fs": [ + 105, + 462, + 506, + 531 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 534, + 505, + 579 + ], + "lines": [ + { + "bbox": [ + 106, + 534, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 106, + 534, + 505, + 546 + ], + "score": 1.0, + "content": "In curriculum training which we use as a baseline, we gradually increase the upper bound on the", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "score": 1.0, + "content": "difficulty of tasks. In the switches environment, the difficulty corresponds to the number of toggles", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 557, + 504, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 557, + 504, + 569 + ], + "score": 1.0, + "content": "necessary for solving the task. The craft environment has two levels of difficulty: tasks can be", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 567, + 455, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 455, + 580 + ], + "score": 1.0, + "content": "completed by a single grab or craft action, and tasks that require multiple such actions.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 534, + 505, + 580 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 584, + 504, + 607 + ], + "lines": [ + { + "bbox": [ + 105, + 582, + 504, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 462, + 599 + ], + "score": 1.0, + "content": "During the second phase of training, we simultaneously compute the transition function", + "type": "text" + }, + { + "bbox": [ + 463, + 584, + 504, + 597 + ], + "score": 0.91, + "content": "c _ { \\pi } ( \\rho _ { i } , \\rho _ { j } )", + "type": "inline_equation" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 595, + 438, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 426, + 608 + ], + "score": 1.0, + "content": "using an exponentially decaying average of success rates of the low level policy", + "type": "text" + }, + { + "bbox": [ + 426, + 597, + 434, + 605 + ], + "score": 0.75, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 595, + 438, + 608 + ], + "score": 1.0, + "content": ":", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 582, + 504, + 608 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 229, + 617, + 381, + 650 + ], + "lines": [ + { + "bbox": [ + 229, + 617, + 381, + 650 + ], + "spans": [ + { + "bbox": [ + 229, + 617, + 381, + 650 + ], + "score": 0.95, + "content": "c _ { \\pi } ( \\rho _ { i } , \\rho _ { j } ) = \\frac { \\sum _ { t = 1 } ^ { T } \\gamma ^ { T - t } M _ { \\pi } ^ { t } ( \\rho _ { i } , \\rho _ { j } ) } { \\sum _ { t = 1 } ^ { T } \\gamma ^ { T - t } N _ { \\pi } ^ { t } ( \\rho _ { i } , \\rho _ { j } ) } ,", + "type": "interline_equation", + "image_path": "77129c3880f0194beedf8e4e4d006ca6fc8f5bfcd1a0b98c75d6b36bad52d10f.jpg" + } + ] + } + ], + "index": 38.5, + "virtual_lines": [ + { + "bbox": [ + 229, + 617, + 381, + 633.5 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 229, + 633.5, + 381, + 650.0 + ], + "spans": [], + "index": 39 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 659, + 503, + 682 + ], + "lines": [ + { + "bbox": [ + 105, + 658, + 503, + 674 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 133, + 674 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 660, + 141, + 670 + ], + "score": 0.8, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 658, + 275, + 674 + ], + "score": 1.0, + "content": "is the number of training epochs,", + "type": "text" + }, + { + "bbox": [ + 275, + 660, + 289, + 672 + ], + "score": 0.9, + "content": "N _ { \\pi } ^ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 658, + 376, + 674 + ], + "score": 1.0, + "content": "is the number of task", + "type": "text" + }, + { + "bbox": [ + 376, + 660, + 407, + 672 + ], + "score": 0.92, + "content": "( \\rho _ { i } , \\rho _ { j } )", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 658, + 462, + 674 + ], + "score": 1.0, + "content": "during epoch", + "type": "text" + }, + { + "bbox": [ + 462, + 661, + 467, + 670 + ], + "score": 0.75, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 468, + 658, + 487, + 674 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 488, + 660, + 503, + 672 + ], + "score": 0.9, + "content": "M _ { \\pi } ^ { t }", + "type": "inline_equation" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 671, + 439, + 682 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 373, + 682 + ], + "score": 1.0, + "content": "is the number of successful episodes among them. A decay rate of", + "type": "text" + }, + { + "bbox": [ + 373, + 672, + 406, + 682 + ], + "score": 0.89, + "content": "\\gamma = 0 . 9", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 671, + 439, + 682 + ], + "score": 1.0, + "content": "is used.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5, + "bbox_fs": [ + 105, + 658, + 503, + 682 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 688, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 505, + 699 + ], + "score": 1.0, + "content": "Table 1 compares our Attribute Planner (AP) model to a Reinforce baseline on the Crafting and", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "Colored Switches tasks. In all cases, the baseline performs poorly, while the AP model has a high", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "success rate. The importance of the graph is apparent: when it is removed (Reinforce method) the", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 721, + 316, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 316, + 733 + ], + "score": 1.0, + "content": "performance drops significantly on multi-step tasks.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43.5, + "bbox_fs": [ + 105, + 688, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 146, + 80, + 465, + 159 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 146, + 80, + 465, + 159 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 146, + 80, + 465, + 159 + ], + "spans": [ + { + "bbox": [ + 146, + 80, + 465, + 159 + ], + "score": 0.979, + "html": "
MethodTraining dataSwitchesCrafting
singlemultisinglemulti
Reinforcemulti-step0.0%0.0%45.7%28.6%
Reinforce multi-step + curriculum33.6%33.3%94.9%83.9%
Reinforceone-step99.0%15.4%98.7%49.0%
APone-step99.0%83.1%98.7%96.2%
", + "type": "table", + "image_path": "a4c3024cf16429bb6f83f8d8e6bc2af3fac2e6327a0aed3a75f8e3f2c9a78093.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 146, + 80, + 465, + 106.33333333333333 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 146, + 106.33333333333333, + 465, + 132.66666666666666 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 146, + 132.66666666666666, + 465, + 159.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 107, + 167, + 504, + 201 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 166, + 505, + 180 + ], + "spans": [ + { + "bbox": [ + 105, + 166, + 505, + 180 + ], + "score": 1.0, + "content": "Table 1: Task success rate on Mazebase environments. Our Attribute Planner (AP) approach per-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 178, + 505, + 191 + ], + "spans": [ + { + "bbox": [ + 106, + 178, + 505, + 191 + ], + "score": 1.0, + "content": "forms much better than the reactive policies trained with Reinforce. The addition of the attribute", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 189, + 412, + 202 + ], + "spans": [ + { + "bbox": [ + 105, + 189, + 412, + 202 + ], + "score": 1.0, + "content": "graph (over Reinforce only model) is crucial for multi-step evaluation tasks.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "title", + "bbox": [ + 108, + 223, + 214, + 234 + ], + "lines": [ + { + "bbox": [ + 105, + 221, + 216, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 216, + 236 + ], + "score": 1.0, + "content": "4.2 STACKING BLOCKS", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 244, + 505, + 333 + ], + "lines": [ + { + "bbox": [ + 105, + 244, + 505, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 505, + 257 + ], + "score": 1.0, + "content": "We consider a 3D block stacking task in the Mujoco environment Todorov et al. (2012). There are", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 255, + 505, + 268 + ], + "spans": [ + { + "bbox": [ + 105, + 255, + 406, + 268 + ], + "score": 1.0, + "content": "4 blocks of different colors, and actions consist of dropping a block in a", + "type": "text" + }, + { + "bbox": [ + 406, + 256, + 432, + 266 + ], + "score": 0.89, + "content": "3 \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 255, + 505, + 268 + ], + "score": 1.0, + "content": "grid of positions,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 266, + 505, + 279 + ], + "spans": [ + { + "bbox": [ + 105, + 266, + 505, + 279 + ], + "score": 1.0, + "content": "resulting in 36 total actions. A block cannot be moved when it is underneath another block, so some", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 278, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 106, + 278, + 505, + 289 + ], + "score": 1.0, + "content": "actions have no effect. The input to the model is the observed image, and there are a total of 36", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 289, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 106, + 289, + 295, + 301 + ], + "score": 1.0, + "content": "binary properties corresponding to the relative", + "type": "text" + }, + { + "bbox": [ + 296, + 290, + 303, + 299 + ], + "score": 0.34, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 303, + 289, + 505, + 301 + ], + "score": 1.0, + "content": "and y positions of the blocks and whether blocks", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 299, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 299, + 505, + 312 + ], + "score": 1.0, + "content": "are stacked on one another. For example, one property corresponds to “blue is on top of yellow”.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 310, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 105, + 310, + 505, + 323 + ], + "score": 1.0, + "content": "Each training episode is initiated from a random initial state and lasts only one step, i.e. dropping a", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 322, + 230, + 334 + ], + "spans": [ + { + "bbox": [ + 106, + 322, + 230, + 334 + ], + "score": 1.0, + "content": "single block in a new location.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 107, + 338, + 505, + 393 + ], + "lines": [ + { + "bbox": [ + 106, + 338, + 504, + 350 + ], + "spans": [ + { + "bbox": [ + 106, + 338, + 231, + 350 + ], + "score": 1.0, + "content": "The policy network takes (i) a", + "type": "text" + }, + { + "bbox": [ + 231, + 338, + 275, + 349 + ], + "score": 0.88, + "content": "1 2 8 \\times 1 2 8", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 338, + 504, + 350 + ], + "score": 1.0, + "content": "image, which is featurized by a CNN with five convolu-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 348, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 505, + 362 + ], + "score": 1.0, + "content": "tional layers and one fully connected (fc) layer to produce a 128d vector; and (ii) goal properties", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 359, + 506, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 506, + 374 + ], + "score": 1.0, + "content": "expressed as a 48d binary vector, which are transformed to a 128d vector. The two 128d vectors are", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 370, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 505, + 385 + ], + "score": 1.0, + "content": "concatenated and combined by two fc layers followed by softmax to produce an output distribution", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 382, + 394, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 382, + 394, + 395 + ], + "score": 1.0, + "content": "over actions. We use an exponential linear nonlinearity after each layer.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 106, + 398, + 505, + 476 + ], + "lines": [ + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "score": 1.0, + "content": "Table 2 compares the performance of different models on several block stacking tasks. In the one-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 410, + 505, + 422 + ], + "spans": [ + { + "bbox": [ + 106, + 410, + 505, + 422 + ], + "score": 1.0, + "content": "step task, a goal is chosen that is the result of taking a single random action. In the multi-step task,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 421, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 505, + 434 + ], + "score": 1.0, + "content": "the goal is chosen as the properties of a new random initialization. These tasks typically require", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 432, + 505, + 444 + ], + "spans": [ + { + "bbox": [ + 106, + 432, + 132, + 443 + ], + "score": 0.56, + "content": "3 - 8", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 432, + 505, + 444 + ], + "score": 1.0, + "content": "steps to complete. In the 4-stack task, the goal is a vertical stack of blocks in the order", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 442, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 106, + 442, + 505, + 455 + ], + "score": 1.0, + "content": "red, green, blue, yellow. We compare the performance of our model to reactive policy baselines", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 454, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 106, + 454, + 505, + 465 + ], + "score": 1.0, + "content": "trained on single-step tasks, complex multi-step tasks or with a curriculum of both. We perform", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 465, + 238, + 477 + ], + "spans": [ + { + "bbox": [ + 106, + 465, + 238, + 477 + ], + "score": 1.0, + "content": "each evaluation task 1000 times.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 481, + 505, + 537 + ], + "lines": [ + { + "bbox": [ + 106, + 481, + 505, + 494 + ], + "spans": [ + { + "bbox": [ + 106, + 481, + 505, + 494 + ], + "score": 1.0, + "content": "The single-step reactive policies perform well on single step tasks (which are what it sees at train", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 493, + 504, + 505 + ], + "spans": [ + { + "bbox": [ + 106, + 493, + 504, + 505 + ], + "score": 1.0, + "content": "time), but perform much worse compared to the AP model when transferred to multi-step tasks.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 502, + 505, + 517 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 355, + 517 + ], + "score": 1.0, + "content": "The AP model without the second step of training that learns", + "type": "text" + }, + { + "bbox": [ + 355, + 505, + 366, + 515 + ], + "score": 0.84, + "content": "c _ { \\pi }", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 502, + 505, + 517 + ], + "score": 1.0, + "content": "also performs substantially worse", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 514, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 514, + 505, + 528 + ], + "score": 1.0, + "content": "on multi-step tasks, demonstrating the importance of properly normalized transition probabilities to", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 525, + 188, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 525, + 188, + 538 + ], + "score": 1.0, + "content": "avoid aliased states.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 542, + 504, + 609 + ], + "lines": [ + { + "bbox": [ + 106, + 543, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 543, + 505, + 554 + ], + "score": 1.0, + "content": "The rightmost two columns of Table 2 consider underspecified goals, where only a subset of the", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 554, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 554, + 505, + 565 + ], + "score": 1.0, + "content": "attributes are provided. These are identical to their fully-specified counterparts, except that each", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 563, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 282, + 578 + ], + "score": 1.0, + "content": "attribute is left unspecified with probability", + "type": "text" + }, + { + "bbox": [ + 282, + 565, + 302, + 575 + ], + "score": 0.86, + "content": "30 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 302, + 563, + 506, + 578 + ], + "score": 1.0, + "content": ". The AP model handles these naturally by finding", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 574, + 506, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 506, + 588 + ], + "score": 1.0, + "content": "the shorted path to any satisfactory attribute set. We consider reactive baselines that are trained on", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 585, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 505, + 599 + ], + "score": 1.0, + "content": "the same distribution of underspecified attribute sets. Despite this, we observe that reactive policy", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 597, + 444, + 610 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 444, + 610 + ], + "score": 1.0, + "content": "performance degrades when goals are underspecified, while our AP model does not.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 34.5 + }, + { + "type": "text", + "bbox": [ + 107, + 614, + 504, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 614, + 506, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 196, + 628 + ], + "score": 1.0, + "content": "The attribute detector", + "type": "text" + }, + { + "bbox": [ + 197, + 614, + 205, + 628 + ], + "score": 0.87, + "content": "\\hat { f }", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 615, + 345, + 628 + ], + "score": 1.0, + "content": "predicts the full attribute set with", + "type": "text" + }, + { + "bbox": [ + 345, + 616, + 380, + 627 + ], + "score": 0.89, + "content": "< 0 . 1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 615, + 506, + 628 + ], + "score": 1.0, + "content": "error when trained on the full", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 627, + 506, + 639 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 506, + 639 + ], + "score": 1.0, + "content": "dataset of 1 million examples. If trained on only 10,000 examples, the attribute detector has an error", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 637, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 136, + 651 + ], + "score": 1.0, + "content": "rate of", + "type": "text" + }, + { + "bbox": [ + 136, + 638, + 158, + 649 + ], + "score": 0.9, + "content": "1 . 4 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 158, + 637, + 506, + 651 + ], + "score": 1.0, + "content": ". Training the AP model with this less-accurate attribute detector degrades multi-step", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 649, + 218, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 192, + 660 + ], + "score": 1.0, + "content": "performance by only", + "type": "text" + }, + { + "bbox": [ + 192, + 649, + 214, + 660 + ], + "score": 0.86, + "content": "0 . 9 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 649, + 218, + 660 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 39.5 + }, + { + "type": "text", + "bbox": [ + 106, + 666, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "Property Aliasing: The “ignorability” assumption we made in Section 2 is violated in the block", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "stacking task. To see why, consider a transition from “red left of blue and yellow” to “red right", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 686, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 506, + 701 + ], + "score": 1.0, + "content": "of blue and yellow”. This can typically be accomplished in one step, but if blue and yellow are", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "already on the far right, it cannot. Thus, states where this transition are possible and impossible are", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "aliased with the same properties. This is the dominant source of errors on the multi-step task when", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 720, + 504, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 479, + 732 + ], + "score": 1.0, + "content": "trained on large sample sizes (in fact, it is the only source of errors as the policy approaches", + "type": "text" + }, + { + "bbox": [ + 479, + 720, + 504, + 731 + ], + "score": 0.87, + "content": "1 0 0 \\%", + "type": "inline_equation" + } + ], + "index": 47 + } + ], + "index": 44.5 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "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": "table", + "bbox": [ + 146, + 80, + 465, + 159 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 146, + 80, + 465, + 159 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 146, + 80, + 465, + 159 + ], + "spans": [ + { + "bbox": [ + 146, + 80, + 465, + 159 + ], + "score": 0.979, + "html": "
MethodTraining dataSwitchesCrafting
singlemultisinglemulti
Reinforcemulti-step0.0%0.0%45.7%28.6%
Reinforce multi-step + curriculum33.6%33.3%94.9%83.9%
Reinforceone-step99.0%15.4%98.7%49.0%
APone-step99.0%83.1%98.7%96.2%
", + "type": "table", + "image_path": "a4c3024cf16429bb6f83f8d8e6bc2af3fac2e6327a0aed3a75f8e3f2c9a78093.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 146, + 80, + 465, + 106.33333333333333 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 146, + 106.33333333333333, + 465, + 132.66666666666666 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 146, + 132.66666666666666, + 465, + 159.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 107, + 167, + 504, + 201 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 166, + 505, + 180 + ], + "spans": [ + { + "bbox": [ + 105, + 166, + 505, + 180 + ], + "score": 1.0, + "content": "Table 1: Task success rate on Mazebase environments. Our Attribute Planner (AP) approach per-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 178, + 505, + 191 + ], + "spans": [ + { + "bbox": [ + 106, + 178, + 505, + 191 + ], + "score": 1.0, + "content": "forms much better than the reactive policies trained with Reinforce. The addition of the attribute", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 189, + 412, + 202 + ], + "spans": [ + { + "bbox": [ + 105, + 189, + 412, + 202 + ], + "score": 1.0, + "content": "graph (over Reinforce only model) is crucial for multi-step evaluation tasks.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "title", + "bbox": [ + 108, + 223, + 214, + 234 + ], + "lines": [ + { + "bbox": [ + 105, + 221, + 216, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 216, + 236 + ], + "score": 1.0, + "content": "4.2 STACKING BLOCKS", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 244, + 505, + 333 + ], + "lines": [ + { + "bbox": [ + 105, + 244, + 505, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 505, + 257 + ], + "score": 1.0, + "content": "We consider a 3D block stacking task in the Mujoco environment Todorov et al. (2012). There are", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 255, + 505, + 268 + ], + "spans": [ + { + "bbox": [ + 105, + 255, + 406, + 268 + ], + "score": 1.0, + "content": "4 blocks of different colors, and actions consist of dropping a block in a", + "type": "text" + }, + { + "bbox": [ + 406, + 256, + 432, + 266 + ], + "score": 0.89, + "content": "3 \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 255, + 505, + 268 + ], + "score": 1.0, + "content": "grid of positions,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 266, + 505, + 279 + ], + "spans": [ + { + "bbox": [ + 105, + 266, + 505, + 279 + ], + "score": 1.0, + "content": "resulting in 36 total actions. A block cannot be moved when it is underneath another block, so some", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 278, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 106, + 278, + 505, + 289 + ], + "score": 1.0, + "content": "actions have no effect. The input to the model is the observed image, and there are a total of 36", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 289, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 106, + 289, + 295, + 301 + ], + "score": 1.0, + "content": "binary properties corresponding to the relative", + "type": "text" + }, + { + "bbox": [ + 296, + 290, + 303, + 299 + ], + "score": 0.34, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 303, + 289, + 505, + 301 + ], + "score": 1.0, + "content": "and y positions of the blocks and whether blocks", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 299, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 299, + 505, + 312 + ], + "score": 1.0, + "content": "are stacked on one another. For example, one property corresponds to “blue is on top of yellow”.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 310, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 105, + 310, + 505, + 323 + ], + "score": 1.0, + "content": "Each training episode is initiated from a random initial state and lasts only one step, i.e. dropping a", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 322, + 230, + 334 + ], + "spans": [ + { + "bbox": [ + 106, + 322, + 230, + 334 + ], + "score": 1.0, + "content": "single block in a new location.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 244, + 505, + 334 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 338, + 505, + 393 + ], + "lines": [ + { + "bbox": [ + 106, + 338, + 504, + 350 + ], + "spans": [ + { + "bbox": [ + 106, + 338, + 231, + 350 + ], + "score": 1.0, + "content": "The policy network takes (i) a", + "type": "text" + }, + { + "bbox": [ + 231, + 338, + 275, + 349 + ], + "score": 0.88, + "content": "1 2 8 \\times 1 2 8", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 338, + 504, + 350 + ], + "score": 1.0, + "content": "image, which is featurized by a CNN with five convolu-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 348, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 505, + 362 + ], + "score": 1.0, + "content": "tional layers and one fully connected (fc) layer to produce a 128d vector; and (ii) goal properties", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 359, + 506, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 506, + 374 + ], + "score": 1.0, + "content": "expressed as a 48d binary vector, which are transformed to a 128d vector. The two 128d vectors are", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 370, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 505, + 385 + ], + "score": 1.0, + "content": "concatenated and combined by two fc layers followed by softmax to produce an output distribution", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 382, + 394, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 382, + 394, + 395 + ], + "score": 1.0, + "content": "over actions. We use an exponential linear nonlinearity after each layer.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 338, + 506, + 395 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 398, + 505, + 476 + ], + "lines": [ + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "score": 1.0, + "content": "Table 2 compares the performance of different models on several block stacking tasks. In the one-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 410, + 505, + 422 + ], + "spans": [ + { + "bbox": [ + 106, + 410, + 505, + 422 + ], + "score": 1.0, + "content": "step task, a goal is chosen that is the result of taking a single random action. In the multi-step task,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 421, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 505, + 434 + ], + "score": 1.0, + "content": "the goal is chosen as the properties of a new random initialization. These tasks typically require", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 432, + 505, + 444 + ], + "spans": [ + { + "bbox": [ + 106, + 432, + 132, + 443 + ], + "score": 0.56, + "content": "3 - 8", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 432, + 505, + 444 + ], + "score": 1.0, + "content": "steps to complete. In the 4-stack task, the goal is a vertical stack of blocks in the order", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 442, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 106, + 442, + 505, + 455 + ], + "score": 1.0, + "content": "red, green, blue, yellow. We compare the performance of our model to reactive policy baselines", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 454, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 106, + 454, + 505, + 465 + ], + "score": 1.0, + "content": "trained on single-step tasks, complex multi-step tasks or with a curriculum of both. We perform", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 465, + 238, + 477 + ], + "spans": [ + { + "bbox": [ + 106, + 465, + 238, + 477 + ], + "score": 1.0, + "content": "each evaluation task 1000 times.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 398, + 505, + 477 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 481, + 505, + 537 + ], + "lines": [ + { + "bbox": [ + 106, + 481, + 505, + 494 + ], + "spans": [ + { + "bbox": [ + 106, + 481, + 505, + 494 + ], + "score": 1.0, + "content": "The single-step reactive policies perform well on single step tasks (which are what it sees at train", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 493, + 504, + 505 + ], + "spans": [ + { + "bbox": [ + 106, + 493, + 504, + 505 + ], + "score": 1.0, + "content": "time), but perform much worse compared to the AP model when transferred to multi-step tasks.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 502, + 505, + 517 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 355, + 517 + ], + "score": 1.0, + "content": "The AP model without the second step of training that learns", + "type": "text" + }, + { + "bbox": [ + 355, + 505, + 366, + 515 + ], + "score": 0.84, + "content": "c _ { \\pi }", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 502, + 505, + 517 + ], + "score": 1.0, + "content": "also performs substantially worse", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 514, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 514, + 505, + 528 + ], + "score": 1.0, + "content": "on multi-step tasks, demonstrating the importance of properly normalized transition probabilities to", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 525, + 188, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 525, + 188, + 538 + ], + "score": 1.0, + "content": "avoid aliased states.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29, + "bbox_fs": [ + 105, + 481, + 505, + 538 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 542, + 504, + 609 + ], + "lines": [ + { + "bbox": [ + 106, + 543, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 543, + 505, + 554 + ], + "score": 1.0, + "content": "The rightmost two columns of Table 2 consider underspecified goals, where only a subset of the", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 554, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 554, + 505, + 565 + ], + "score": 1.0, + "content": "attributes are provided. These are identical to their fully-specified counterparts, except that each", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 563, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 282, + 578 + ], + "score": 1.0, + "content": "attribute is left unspecified with probability", + "type": "text" + }, + { + "bbox": [ + 282, + 565, + 302, + 575 + ], + "score": 0.86, + "content": "30 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 302, + 563, + 506, + 578 + ], + "score": 1.0, + "content": ". The AP model handles these naturally by finding", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 574, + 506, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 506, + 588 + ], + "score": 1.0, + "content": "the shorted path to any satisfactory attribute set. We consider reactive baselines that are trained on", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 585, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 505, + 599 + ], + "score": 1.0, + "content": "the same distribution of underspecified attribute sets. Despite this, we observe that reactive policy", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 597, + 444, + 610 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 444, + 610 + ], + "score": 1.0, + "content": "performance degrades when goals are underspecified, while our AP model does not.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 543, + 506, + 610 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 614, + 504, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 614, + 506, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 196, + 628 + ], + "score": 1.0, + "content": "The attribute detector", + "type": "text" + }, + { + "bbox": [ + 197, + 614, + 205, + 628 + ], + "score": 0.87, + "content": "\\hat { f }", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 615, + 345, + 628 + ], + "score": 1.0, + "content": "predicts the full attribute set with", + "type": "text" + }, + { + "bbox": [ + 345, + 616, + 380, + 627 + ], + "score": 0.89, + "content": "< 0 . 1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 615, + 506, + 628 + ], + "score": 1.0, + "content": "error when trained on the full", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 627, + 506, + 639 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 506, + 639 + ], + "score": 1.0, + "content": "dataset of 1 million examples. If trained on only 10,000 examples, the attribute detector has an error", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 637, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 136, + 651 + ], + "score": 1.0, + "content": "rate of", + "type": "text" + }, + { + "bbox": [ + 136, + 638, + 158, + 649 + ], + "score": 0.9, + "content": "1 . 4 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 158, + 637, + 506, + 651 + ], + "score": 1.0, + "content": ". Training the AP model with this less-accurate attribute detector degrades multi-step", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 649, + 218, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 192, + 660 + ], + "score": 1.0, + "content": "performance by only", + "type": "text" + }, + { + "bbox": [ + 192, + 649, + 214, + 660 + ], + "score": 0.86, + "content": "0 . 9 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 649, + 218, + 660 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 39.5, + "bbox_fs": [ + 105, + 614, + 506, + 660 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 666, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "Property Aliasing: The “ignorability” assumption we made in Section 2 is violated in the block", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "stacking task. To see why, consider a transition from “red left of blue and yellow” to “red right", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 686, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 506, + 701 + ], + "score": 1.0, + "content": "of blue and yellow”. This can typically be accomplished in one step, but if blue and yellow are", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "already on the far right, it cannot. Thus, states where this transition are possible and impossible are", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "aliased with the same properties. This is the dominant source of errors on the multi-step task when", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 720, + 504, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 479, + 732 + ], + "score": 1.0, + "content": "trained on large sample sizes (in fact, it is the only source of errors as the policy approaches", + "type": "text" + }, + { + "bbox": [ + 479, + 720, + 504, + 731 + ], + "score": 0.87, + "content": "1 0 0 \\%", + "type": "inline_equation" + } + ], + "index": 47 + } + ], + "index": 44.5, + "bbox_fs": [ + 105, + 665, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 130, + 80, + 481, + 192 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 130, + 80, + 481, + 192 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 130, + 80, + 481, + 192 + ], + "spans": [ + { + "bbox": [ + 130, + 80, + 481, + 192 + ], + "score": 0.984, + "html": "
ModelTraining Dataone-stepmulti-step4-stackone-step underspecifiedmulti-step
A3Cone-step98.5%8.1%1.9%65.7%6.6%
A3Cmulti-step2.6%0%0%5.3%0%
A3Ccurriculum98.2%17%2.9%8.2%0.2%
Inverseone-step100%9.1%0.5%98.8%18.8%
Inversemulti-step94.1%13.7%4.6%71.2%9.6%
AP (no Cπ) one-step74.5%29.7%62.2%81.8%28.1%
APone-step98.8%66.7%98.5%97.8%63.5%
", + "type": "table", + "image_path": "97cefae6f4a25c134baed4690fefe030b065d411d2535d16a47dea4aa6161483.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 130, + 80, + 481, + 117.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 130, + 117.33333333333334, + 481, + 154.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 130, + 154.66666666666669, + 481, + 192.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 106, + 204, + 505, + 293 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 205, + 505, + 217 + ], + "spans": [ + { + "bbox": [ + 106, + 205, + 505, + 217 + ], + "score": 1.0, + "content": "Table 2: Model comparison on block stacking task accuracy. Baselines marked ‘multi-step’ or ‘cur-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 216, + 505, + 228 + ], + "spans": [ + { + "bbox": [ + 106, + 216, + 505, + 228 + ], + "score": 1.0, + "content": "riculum‘ get to see complex multi-step tasks at train time. The Attribute Planner (AP) generalizes", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 228, + 505, + 239 + ], + "spans": [ + { + "bbox": [ + 106, + 228, + 505, + 239 + ], + "score": 1.0, + "content": "from one-step training to multi-step and underspecified tasks with high accuracy, while reinforce-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 238, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 505, + 250 + ], + "score": 1.0, + "content": "ment learning and inverse model training do not. AP outperforms A3C even with a curriculum of", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 249, + 505, + 261 + ], + "spans": [ + { + "bbox": [ + 106, + 249, + 320, + 261 + ], + "score": 1.0, + "content": "tasks. Ablating the normalized graph transition table", + "type": "text" + }, + { + "bbox": [ + 320, + 250, + 331, + 260 + ], + "score": 0.86, + "content": "c _ { \\pi }", + "type": "inline_equation" + }, + { + "bbox": [ + 332, + 249, + 505, + 261 + ], + "score": 1.0, + "content": "degrades AP performance substantially on", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 260, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 106, + 260, + 505, + 272 + ], + "score": 1.0, + "content": "multi-step tasks due to aliasing. Inverse one-step model was trained on 2 million examples, in-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 271, + 505, + 283 + ], + "spans": [ + { + "bbox": [ + 106, + 271, + 505, + 283 + ], + "score": 1.0, + "content": "verse multi-step and AP models were trained on 1 million examples, A3C models were trained to", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 283, + 162, + 294 + ], + "spans": [ + { + "bbox": [ + 106, + 283, + 162, + 294 + ], + "score": 1.0, + "content": "convergence.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6.5 + } + ], + "index": 3.75 + }, + { + "type": "table", + "bbox": [ + 174, + 303, + 437, + 382 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 174, + 303, + 437, + 382 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 174, + 303, + 437, + 382 + ], + "spans": [ + { + "bbox": [ + 174, + 303, + 437, + 382 + ], + "score": 0.98, + "html": "
# of Training ExamplesInverseAP
one-stepmulti-stepone-stepmulti-step
10,00035.5%1.6%50.0%3.0%
100,00099.9%7.8%89.0%47.0%
1,000,000100%9.1%98.9%66.7%
10,000,000100%8.5%96.5%70.7%
", + "type": "table", + "image_path": "d94ce6877d1871186eb83817ffa1d1a005b5a2ab4d985ac0b3c9929066073333.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 174, + 303, + 437, + 329.3333333333333 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 174, + 329.3333333333333, + 437, + 355.66666666666663 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 174, + 355.66666666666663, + 437, + 381.99999999999994 + ], + "spans": [], + "index": 13 + } + ] + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 108, + 395, + 504, + 429 + ], + "lines": [ + { + "bbox": [ + 105, + 394, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 505, + 408 + ], + "score": 1.0, + "content": "Table 3: Effect of the number of (one-step) training examples on one-step and multi-step perfor-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 406, + 504, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 492, + 418 + ], + "score": 1.0, + "content": "mance, for an inverse model and the Attribute Planner model. The inverse models are trained on", + "type": "text" + }, + { + "bbox": [ + 492, + 406, + 504, + 416 + ], + "score": 0.74, + "content": "2 \\mathbf { x }", + "type": "inline_equation" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 417, + 434, + 429 + ], + "spans": [ + { + "bbox": [ + 106, + 417, + 345, + 429 + ], + "score": 1.0, + "content": "the samples, including the samples generated from learning", + "type": "text" + }, + { + "bbox": [ + 346, + 419, + 357, + 428 + ], + "score": 0.85, + "content": "c _ { \\pi }", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 417, + 434, + 429 + ], + "score": 1.0, + "content": "in our AP method.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 107, + 448, + 504, + 471 + ], + "lines": [ + { + "bbox": [ + 105, + 448, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 505, + 461 + ], + "score": 1.0, + "content": "accuracy and the graph becomes complete). Figure 4 shows an example plan that becomes stuck", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 457, + 170, + 473 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 170, + 473 + ], + "score": 1.0, + "content": "due to aliasing.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 107, + 475, + 505, + 531 + ], + "lines": [ + { + "bbox": [ + 106, + 476, + 505, + 488 + ], + "spans": [ + { + "bbox": [ + 106, + 476, + 348, + 488 + ], + "score": 1.0, + "content": "The second step of training, that computes the probability of", + "type": "text" + }, + { + "bbox": [ + 349, + 478, + 356, + 486 + ], + "score": 0.73, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 476, + 505, + 488 + ], + "score": 1.0, + "content": "transitioning on each edge, is impor-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 487, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 505, + 500 + ], + "score": 1.0, + "content": "tant for mitigating the effects of aliasing in the block stacking task. The graph search finds the path", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 497, + 505, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 505, + 510 + ], + "score": 1.0, + "content": "with the highest probability of success (i.e. the product of probabilities on each edge), so it avoids", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 508, + 506, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 508, + 506, + 523 + ], + "score": 1.0, + "content": "edges that have high aliasing. In the AP model trained on one million samples, the second step of", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 520, + 450, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 520, + 297, + 532 + ], + "score": 1.0, + "content": "training improves multi-step performance from", + "type": "text" + }, + { + "bbox": [ + 297, + 520, + 324, + 531 + ], + "score": 0.87, + "content": "2 9 . 7 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 520, + 335, + 532 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 336, + 520, + 363, + 531 + ], + "score": 0.88, + "content": "6 6 . 7 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 520, + 450, + 532 + ], + "score": 1.0, + "content": ", as shown in Table 2.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21 + }, + { + "type": "title", + "bbox": [ + 107, + 547, + 190, + 560 + ], + "lines": [ + { + "bbox": [ + 105, + 546, + 192, + 562 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 192, + 562 + ], + "score": 1.0, + "content": "5 DISCUSSION", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 572, + 505, + 637 + ], + "lines": [ + { + "bbox": [ + 105, + 571, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 571, + 506, + 585 + ], + "score": 1.0, + "content": "Our results show that structuring the space of tasks with high level attributes allows an agent to", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 583, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 583, + 505, + 595 + ], + "score": 1.0, + "content": "compose policies for the solutions of simple tasks into solutions of more complex tasks. The agent", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 595, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 106, + 595, + 505, + 606 + ], + "score": 1.0, + "content": "plans a path to the final goal at the level of the attributes, and executes the steps in this path with a", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 605, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 106, + 605, + 505, + 617 + ], + "score": 1.0, + "content": "reactive policy. Thus, supervision of an agent by labeling attributes can lead to generalization from", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 616, + 506, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 616, + 506, + 628 + ], + "score": 1.0, + "content": "simple tasks at train time to more complex tasks at test time. Nevertheless, there are many fronts for", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 627, + 161, + 637 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 161, + 637 + ], + "score": 1.0, + "content": "further work:", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 107, + 643, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 644, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 505, + 656 + ], + "score": 1.0, + "content": "Sample complexity of the planning module: In Table 5 we can see both the benefits and the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 309, + 667 + ], + "score": 1.0, + "content": "liabilities of the explicit non-parametric form for", + "type": "text" + }, + { + "bbox": [ + 310, + 657, + 315, + 665 + ], + "score": 0.38, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 655, + 505, + 667 + ], + "score": 1.0, + "content": ". By 10K samples, the parametric lower level", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "policy is already able to have a reasonable success rate. However, because in this environment,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "there are roughly 200K edges in the graph, most of the edges have not been seen, and without any", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 688, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 700 + ], + "score": 1.0, + "content": "weight-sharing, our model cannot estimate these transition probabilities. On the other hand, by 100K", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "samples the model has seen enough of the graph to make nontrivial plans; and the non-parametric", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "form of the graph makes planning straightforward. In future work, we hope to combine parametric", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 153, + 733 + ], + "score": 1.0, + "content": "models for", + "type": "text" + }, + { + "bbox": [ + 154, + 722, + 159, + 730 + ], + "score": 0.55, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "with search to increase the sample efficiency of the planning module. Alternatively,", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 34.5 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 300, + 750, + 309, + 761 + ], + "spans": [ + { + "bbox": [ + 300, + 750, + 309, + 761 + ], + "score": 1.0, + "content": "8", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 130, + 80, + 481, + 192 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 130, + 80, + 481, + 192 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 130, + 80, + 481, + 192 + ], + "spans": [ + { + "bbox": [ + 130, + 80, + 481, + 192 + ], + "score": 0.984, + "html": "
ModelTraining Dataone-stepmulti-step4-stackone-step underspecifiedmulti-step
A3Cone-step98.5%8.1%1.9%65.7%6.6%
A3Cmulti-step2.6%0%0%5.3%0%
A3Ccurriculum98.2%17%2.9%8.2%0.2%
Inverseone-step100%9.1%0.5%98.8%18.8%
Inversemulti-step94.1%13.7%4.6%71.2%9.6%
AP (no Cπ) one-step74.5%29.7%62.2%81.8%28.1%
APone-step98.8%66.7%98.5%97.8%63.5%
", + "type": "table", + "image_path": "97cefae6f4a25c134baed4690fefe030b065d411d2535d16a47dea4aa6161483.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 130, + 80, + 481, + 117.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 130, + 117.33333333333334, + 481, + 154.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 130, + 154.66666666666669, + 481, + 192.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 106, + 204, + 505, + 293 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 205, + 505, + 217 + ], + "spans": [ + { + "bbox": [ + 106, + 205, + 505, + 217 + ], + "score": 1.0, + "content": "Table 2: Model comparison on block stacking task accuracy. Baselines marked ‘multi-step’ or ‘cur-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 216, + 505, + 228 + ], + "spans": [ + { + "bbox": [ + 106, + 216, + 505, + 228 + ], + "score": 1.0, + "content": "riculum‘ get to see complex multi-step tasks at train time. The Attribute Planner (AP) generalizes", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 228, + 505, + 239 + ], + "spans": [ + { + "bbox": [ + 106, + 228, + 505, + 239 + ], + "score": 1.0, + "content": "from one-step training to multi-step and underspecified tasks with high accuracy, while reinforce-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 238, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 505, + 250 + ], + "score": 1.0, + "content": "ment learning and inverse model training do not. AP outperforms A3C even with a curriculum of", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 249, + 505, + 261 + ], + "spans": [ + { + "bbox": [ + 106, + 249, + 320, + 261 + ], + "score": 1.0, + "content": "tasks. Ablating the normalized graph transition table", + "type": "text" + }, + { + "bbox": [ + 320, + 250, + 331, + 260 + ], + "score": 0.86, + "content": "c _ { \\pi }", + "type": "inline_equation" + }, + { + "bbox": [ + 332, + 249, + 505, + 261 + ], + "score": 1.0, + "content": "degrades AP performance substantially on", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 260, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 106, + 260, + 505, + 272 + ], + "score": 1.0, + "content": "multi-step tasks due to aliasing. Inverse one-step model was trained on 2 million examples, in-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 271, + 505, + 283 + ], + "spans": [ + { + "bbox": [ + 106, + 271, + 505, + 283 + ], + "score": 1.0, + "content": "verse multi-step and AP models were trained on 1 million examples, A3C models were trained to", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 283, + 162, + 294 + ], + "spans": [ + { + "bbox": [ + 106, + 283, + 162, + 294 + ], + "score": 1.0, + "content": "convergence.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6.5 + } + ], + "index": 3.75 + }, + { + "type": "table", + "bbox": [ + 174, + 303, + 437, + 382 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 174, + 303, + 437, + 382 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 174, + 303, + 437, + 382 + ], + "spans": [ + { + "bbox": [ + 174, + 303, + 437, + 382 + ], + "score": 0.98, + "html": "
# of Training ExamplesInverseAP
one-stepmulti-stepone-stepmulti-step
10,00035.5%1.6%50.0%3.0%
100,00099.9%7.8%89.0%47.0%
1,000,000100%9.1%98.9%66.7%
10,000,000100%8.5%96.5%70.7%
", + "type": "table", + "image_path": "d94ce6877d1871186eb83817ffa1d1a005b5a2ab4d985ac0b3c9929066073333.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 174, + 303, + 437, + 329.3333333333333 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 174, + 329.3333333333333, + 437, + 355.66666666666663 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 174, + 355.66666666666663, + 437, + 381.99999999999994 + ], + "spans": [], + "index": 13 + } + ] + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 108, + 395, + 504, + 429 + ], + "lines": [ + { + "bbox": [ + 105, + 394, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 505, + 408 + ], + "score": 1.0, + "content": "Table 3: Effect of the number of (one-step) training examples on one-step and multi-step perfor-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 406, + 504, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 492, + 418 + ], + "score": 1.0, + "content": "mance, for an inverse model and the Attribute Planner model. The inverse models are trained on", + "type": "text" + }, + { + "bbox": [ + 492, + 406, + 504, + 416 + ], + "score": 0.74, + "content": "2 \\mathbf { x }", + "type": "inline_equation" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 417, + 434, + 429 + ], + "spans": [ + { + "bbox": [ + 106, + 417, + 345, + 429 + ], + "score": 1.0, + "content": "the samples, including the samples generated from learning", + "type": "text" + }, + { + "bbox": [ + 346, + 419, + 357, + 428 + ], + "score": 0.85, + "content": "c _ { \\pi }", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 417, + 434, + 429 + ], + "score": 1.0, + "content": "in our AP method.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 394, + 505, + 429 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 448, + 504, + 471 + ], + "lines": [ + { + "bbox": [ + 105, + 448, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 505, + 461 + ], + "score": 1.0, + "content": "accuracy and the graph becomes complete). Figure 4 shows an example plan that becomes stuck", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 457, + 170, + 473 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 170, + 473 + ], + "score": 1.0, + "content": "due to aliasing.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5, + "bbox_fs": [ + 105, + 448, + 505, + 473 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 475, + 505, + 531 + ], + "lines": [ + { + "bbox": [ + 106, + 476, + 505, + 488 + ], + "spans": [ + { + "bbox": [ + 106, + 476, + 348, + 488 + ], + "score": 1.0, + "content": "The second step of training, that computes the probability of", + "type": "text" + }, + { + "bbox": [ + 349, + 478, + 356, + 486 + ], + "score": 0.73, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 476, + 505, + 488 + ], + "score": 1.0, + "content": "transitioning on each edge, is impor-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 487, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 505, + 500 + ], + "score": 1.0, + "content": "tant for mitigating the effects of aliasing in the block stacking task. The graph search finds the path", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 497, + 505, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 505, + 510 + ], + "score": 1.0, + "content": "with the highest probability of success (i.e. the product of probabilities on each edge), so it avoids", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 508, + 506, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 508, + 506, + 523 + ], + "score": 1.0, + "content": "edges that have high aliasing. In the AP model trained on one million samples, the second step of", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 520, + 450, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 520, + 297, + 532 + ], + "score": 1.0, + "content": "training improves multi-step performance from", + "type": "text" + }, + { + "bbox": [ + 297, + 520, + 324, + 531 + ], + "score": 0.87, + "content": "2 9 . 7 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 520, + 335, + 532 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 336, + 520, + 363, + 531 + ], + "score": 0.88, + "content": "6 6 . 7 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 520, + 450, + 532 + ], + "score": 1.0, + "content": ", as shown in Table 2.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 476, + 506, + 532 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 547, + 190, + 560 + ], + "lines": [ + { + "bbox": [ + 105, + 546, + 192, + 562 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 192, + 562 + ], + "score": 1.0, + "content": "5 DISCUSSION", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 572, + 505, + 637 + ], + "lines": [ + { + "bbox": [ + 105, + 571, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 571, + 506, + 585 + ], + "score": 1.0, + "content": "Our results show that structuring the space of tasks with high level attributes allows an agent to", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 583, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 583, + 505, + 595 + ], + "score": 1.0, + "content": "compose policies for the solutions of simple tasks into solutions of more complex tasks. The agent", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 595, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 106, + 595, + 505, + 606 + ], + "score": 1.0, + "content": "plans a path to the final goal at the level of the attributes, and executes the steps in this path with a", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 605, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 106, + 605, + 505, + 617 + ], + "score": 1.0, + "content": "reactive policy. Thus, supervision of an agent by labeling attributes can lead to generalization from", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 616, + 506, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 616, + 506, + 628 + ], + "score": 1.0, + "content": "simple tasks at train time to more complex tasks at test time. Nevertheless, there are many fronts for", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 627, + 161, + 637 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 161, + 637 + ], + "score": 1.0, + "content": "further work:", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 571, + 506, + 637 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 643, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 644, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 505, + 656 + ], + "score": 1.0, + "content": "Sample complexity of the planning module: In Table 5 we can see both the benefits and the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 309, + 667 + ], + "score": 1.0, + "content": "liabilities of the explicit non-parametric form for", + "type": "text" + }, + { + "bbox": [ + 310, + 657, + 315, + 665 + ], + "score": 0.38, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 655, + 505, + 667 + ], + "score": 1.0, + "content": ". By 10K samples, the parametric lower level", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "policy is already able to have a reasonable success rate. However, because in this environment,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "there are roughly 200K edges in the graph, most of the edges have not been seen, and without any", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 688, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 700 + ], + "score": 1.0, + "content": "weight-sharing, our model cannot estimate these transition probabilities. On the other hand, by 100K", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "samples the model has seen enough of the graph to make nontrivial plans; and the non-parametric", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "form of the graph makes planning straightforward. In future work, we hope to combine parametric", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 153, + 733 + ], + "score": 1.0, + "content": "models for", + "type": "text" + }, + { + "bbox": [ + 154, + 722, + 159, + 730 + ], + "score": 0.55, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "with search to increase the sample efficiency of the planning module. Alternatively,", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 505, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 505, + 518 + ], + "score": 1.0, + "content": "we might hope to make progress on dynamic abstraction (projecting out some of the attributes)", + "type": "text", + "cross_page": true + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 516, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 106, + 516, + 505, + 528 + ], + "score": 1.0, + "content": "depending on the current state and goal, which would make the effective number of edges of the", + "type": "text", + "cross_page": true + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 528, + 165, + 540 + ], + "spans": [ + { + "bbox": [ + 104, + 528, + 165, + 540 + ], + "score": 1.0, + "content": "graph smaller.", + "type": "text", + "cross_page": true + } + ], + "index": 14 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 644, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 81, + 505, + 323 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 81, + 505, + 323 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 81, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 505, + 323 + ], + "score": 0.974, + "type": "image", + "image_path": "28355570631ffc144872cd6f11841f5407f326abc233c5b68f14159249e3594a.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 81, + 505, + 161.66666666666669 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 161.66666666666669, + 505, + 242.33333333333337 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 242.33333333333337, + 505, + 323.00000000000006 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 327, + 505, + 361 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 327, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 106, + 327, + 505, + 340 + ], + "score": 1.0, + "content": "Figure 3: Two examples of block stacking evaluation tasks. The initial/target states are shown in the", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 338, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 106, + 338, + 505, + 351 + ], + "score": 1.0, + "content": "first/last columns. Successful completions of our Attribute Planner model are shown in rows 1 and", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 350, + 421, + 362 + ], + "spans": [ + { + "bbox": [ + 106, + 350, + 421, + 362 + ], + "score": 1.0, + "content": "3. By contrast, the A3C baseline is unable to perform the tasks (rows 2 and 4).", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "image", + "bbox": [ + 107, + 384, + 505, + 437 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 384, + 505, + 437 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 107, + 384, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 107, + 384, + 505, + 437 + ], + "score": 0.959, + "type": "image", + "image_path": "35f4098d826e9a1a5ae3af6917e525e9329c4b3a9e2f382cb0d7bf06f8ec0fc0.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 107, + 384, + 505, + 401.6666666666667 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 107, + 401.6666666666667, + 505, + 419.33333333333337 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 107, + 419.33333333333337, + 505, + 437.00000000000006 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 444, + 505, + 478 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 444, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 106, + 444, + 505, + 456 + ], + "score": 1.0, + "content": "Figure 4: Plans become stuck when states with different transitions map to the same properties. In", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 455, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 106, + 455, + 505, + 468 + ], + "score": 1.0, + "content": "frame 4 of this example, the policy is directed to place the green block in front of the red and blue", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 466, + 474, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 474, + 479 + ], + "score": 1.0, + "content": "blocks, but this is impossible because the blue and red are already in the frontmost position.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 107, + 505, + 505, + 538 + ], + "lines": [ + { + "bbox": [ + 106, + 505, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 505, + 518 + ], + "score": 1.0, + "content": "we might hope to make progress on dynamic abstraction (projecting out some of the attributes)", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 516, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 106, + 516, + 505, + 528 + ], + "score": 1.0, + "content": "depending on the current state and goal, which would make the effective number of edges of the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 528, + 165, + 540 + ], + "spans": [ + { + "bbox": [ + 104, + 528, + 165, + 540 + ], + "score": 1.0, + "content": "graph smaller.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 544, + 505, + 643 + ], + "lines": [ + { + "bbox": [ + 105, + 544, + 505, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 505, + 557 + ], + "score": 1.0, + "content": "Exploration Although we discuss an agent in an environment, we have elided many of the diffi-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 556, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 106, + 556, + 505, + 568 + ], + "score": 1.0, + "content": "cult problems of reinforcement learning. In particular, the environments considered in this work", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 567, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 505, + 578 + ], + "score": 1.0, + "content": "allow sampling low level transitions by starting at random states and following random policies, and", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 577, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 505, + 590 + ], + "score": 1.0, + "content": "these are sufficient to cover the state space, although we note that the method for training the model", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 587, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 505, + 601 + ], + "score": 1.0, + "content": "described in Section 2.1 allows for more sophisticated exploration policies. Thus we sidestep the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 598, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 505, + 613 + ], + "score": 1.0, + "content": "exploration problem, one of the key difficulties of reinforcement learning. Nevertheless, building", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 610, + 504, + 622 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 504, + 622 + ], + "score": 1.0, + "content": "composable models even in this setting is nontrivial, and our view is that it is important to demon-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 621, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 505, + 635 + ], + "score": 1.0, + "content": "strate success here (and decouple issues of exploration and composability) before moving on to the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 632, + 176, + 644 + ], + "spans": [ + { + "bbox": [ + 106, + 632, + 176, + 644 + ], + "score": 1.0, + "content": "full RL problem.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 649, + 505, + 682 + ], + "lines": [ + { + "bbox": [ + 106, + 648, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 225, + 661 + ], + "score": 1.0, + "content": "We believe that the attributes", + "type": "text" + }, + { + "bbox": [ + 225, + 651, + 232, + 660 + ], + "score": 0.81, + "content": "\\rho", + "type": "inline_equation" + }, + { + "bbox": [ + 233, + 648, + 250, + 661 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 250, + 651, + 256, + 659 + ], + "score": 0.65, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 648, + 505, + 661 + ], + "score": 1.0, + "content": ", in addition to their usefulness for planning, provide a frame-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "work for incentivizing exploration. The agent can be rewarded for finding unseen (or rarely-seen)", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 671, + 499, + 683 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 489, + 683 + ], + "score": 1.0, + "content": "high level transitions, or for validating or falsifying hypotheses about the existence of entries of", + "type": "text" + }, + { + "bbox": [ + 489, + 673, + 495, + 681 + ], + "score": 0.58, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 671, + 499, + 683 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 688, + 506, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 699 + ], + "score": 1.0, + "content": "Learning the attributes: Discovering the attributes automatically would remove much of the need", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "for human supervision. Recent work, such as Thomas et al. (2017), demonstrates how this could be", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "done. Another avenue for discovering attributes is to use a few “seed” attributes; and use aliasing as", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 721, + 296, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 296, + 732 + ], + "score": 1.0, + "content": "a signal that some attributes need to be refined.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28.5 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 81, + 505, + 323 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 81, + 505, + 323 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 81, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 505, + 323 + ], + "score": 0.974, + "type": "image", + "image_path": "28355570631ffc144872cd6f11841f5407f326abc233c5b68f14159249e3594a.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 81, + 505, + 161.66666666666669 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 161.66666666666669, + 505, + 242.33333333333337 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 242.33333333333337, + 505, + 323.00000000000006 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 327, + 505, + 361 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 327, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 106, + 327, + 505, + 340 + ], + "score": 1.0, + "content": "Figure 3: Two examples of block stacking evaluation tasks. The initial/target states are shown in the", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 338, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 106, + 338, + 505, + 351 + ], + "score": 1.0, + "content": "first/last columns. Successful completions of our Attribute Planner model are shown in rows 1 and", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 350, + 421, + 362 + ], + "spans": [ + { + "bbox": [ + 106, + 350, + 421, + 362 + ], + "score": 1.0, + "content": "3. By contrast, the A3C baseline is unable to perform the tasks (rows 2 and 4).", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "image", + "bbox": [ + 107, + 384, + 505, + 437 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 384, + 505, + 437 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 107, + 384, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 107, + 384, + 505, + 437 + ], + "score": 0.959, + "type": "image", + "image_path": "35f4098d826e9a1a5ae3af6917e525e9329c4b3a9e2f382cb0d7bf06f8ec0fc0.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 107, + 384, + 505, + 401.6666666666667 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 107, + 401.6666666666667, + 505, + 419.33333333333337 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 107, + 419.33333333333337, + 505, + 437.00000000000006 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 444, + 505, + 478 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 444, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 106, + 444, + 505, + 456 + ], + "score": 1.0, + "content": "Figure 4: Plans become stuck when states with different transitions map to the same properties. In", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 455, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 106, + 455, + 505, + 468 + ], + "score": 1.0, + "content": "frame 4 of this example, the policy is directed to place the green block in front of the red and blue", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 466, + 474, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 474, + 479 + ], + "score": 1.0, + "content": "blocks, but this is impossible because the blue and red are already in the frontmost position.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 107, + 505, + 505, + 538 + ], + "lines": [], + "index": 13, + "bbox_fs": [ + 104, + 505, + 505, + 540 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 544, + 505, + 643 + ], + "lines": [ + { + "bbox": [ + 105, + 544, + 505, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 505, + 557 + ], + "score": 1.0, + "content": "Exploration Although we discuss an agent in an environment, we have elided many of the diffi-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 556, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 106, + 556, + 505, + 568 + ], + "score": 1.0, + "content": "cult problems of reinforcement learning. In particular, the environments considered in this work", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 567, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 505, + 578 + ], + "score": 1.0, + "content": "allow sampling low level transitions by starting at random states and following random policies, and", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 577, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 505, + 590 + ], + "score": 1.0, + "content": "these are sufficient to cover the state space, although we note that the method for training the model", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 587, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 505, + 601 + ], + "score": 1.0, + "content": "described in Section 2.1 allows for more sophisticated exploration policies. Thus we sidestep the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 598, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 505, + 613 + ], + "score": 1.0, + "content": "exploration problem, one of the key difficulties of reinforcement learning. Nevertheless, building", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 610, + 504, + 622 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 504, + 622 + ], + "score": 1.0, + "content": "composable models even in this setting is nontrivial, and our view is that it is important to demon-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 621, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 505, + 635 + ], + "score": 1.0, + "content": "strate success here (and decouple issues of exploration and composability) before moving on to the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 632, + 176, + 644 + ], + "spans": [ + { + "bbox": [ + 106, + 632, + 176, + 644 + ], + "score": 1.0, + "content": "full RL problem.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 19, + "bbox_fs": [ + 105, + 544, + 505, + 644 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 649, + 505, + 682 + ], + "lines": [ + { + "bbox": [ + 106, + 648, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 225, + 661 + ], + "score": 1.0, + "content": "We believe that the attributes", + "type": "text" + }, + { + "bbox": [ + 225, + 651, + 232, + 660 + ], + "score": 0.81, + "content": "\\rho", + "type": "inline_equation" + }, + { + "bbox": [ + 233, + 648, + 250, + 661 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 250, + 651, + 256, + 659 + ], + "score": 0.65, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 648, + 505, + 661 + ], + "score": 1.0, + "content": ", in addition to their usefulness for planning, provide a frame-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "work for incentivizing exploration. The agent can be rewarded for finding unseen (or rarely-seen)", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 671, + 499, + 683 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 489, + 683 + ], + "score": 1.0, + "content": "high level transitions, or for validating or falsifying hypotheses about the existence of entries of", + "type": "text" + }, + { + "bbox": [ + 489, + 673, + 495, + 681 + ], + "score": 0.58, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 671, + 499, + 683 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25, + "bbox_fs": [ + 106, + 648, + 505, + 683 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 688, + 506, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 699 + ], + "score": 1.0, + "content": "Learning the attributes: Discovering the attributes automatically would remove much of the need", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "for human supervision. Recent work, such as Thomas et al. (2017), demonstrates how this could be", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "done. Another avenue for discovering attributes is to use a few “seed” attributes; and use aliasing as", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 721, + 296, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 296, + 732 + ], + "score": 1.0, + "content": "a signal that some attributes need to be refined.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28.5, + "bbox_fs": [ + 105, + 688, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 176, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 176, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 176, + 95 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 100, + 505, + 133 + ], + "lines": [ + { + "bbox": [ + 105, + 99, + 505, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 505, + 113 + ], + "score": 1.0, + "content": "David Abel, D. Ellis Hershkowitz, Gabriel Barth-Maron, Stephen Brawner, Kevin O’Farrell, James", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 114, + 110, + 506, + 125 + ], + "spans": [ + { + "bbox": [ + 114, + 110, + 506, + 125 + ], + "score": 1.0, + "content": "MacGlashan, and Stefanie Tellex. Goal-based action priors. In ICAPS, pp. 306–314. AAAI Press,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 114, + 120, + 143, + 135 + ], + "spans": [ + { + "bbox": [ + 114, + 120, + 143, + 135 + ], + "score": 1.0, + "content": "2015.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 106, + 142, + 569, + 209 + ], + "lines": [ + { + "bbox": [ + 105, + 141, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 105, + 141, + 505, + 155 + ], + "score": 1.0, + "content": "Pulkit Agrawal, Ashvin V Nair, Pieter Abbeel, Jitendra Malik, and Sergey Levine. Learning to poke", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 114, + 153, + 505, + 168 + ], + "spans": [ + { + "bbox": [ + 114, + 153, + 505, + 168 + ], + "score": 1.0, + "content": "by poking: Experiential learning of intuitive physics. In D. D. Lee, M. Sugiyama, U. V. Luxburg,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 114, + 163, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 114, + 163, + 505, + 177 + ], + "score": 1.0, + "content": "I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 174, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 115, + 174, + 505, + 189 + ], + "score": 1.0, + "content": "pp. 5074–5082. Curran Associates, Inc., 2016. URL http://papers.nips.cc/paper/", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 186, + 572, + 199 + ], + "spans": [ + { + "bbox": [ + 115, + 186, + 572, + 199 + ], + "score": 1.0, + "content": "6113-learning-to-poke-by-poking-experiential-learning-of-intuitive-physics.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 114, + 198, + 140, + 209 + ], + "spans": [ + { + "bbox": [ + 114, + 198, + 140, + 209 + ], + "score": 1.0, + "content": "pdf.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 106, + 217, + 507, + 251 + ], + "lines": [ + { + "bbox": [ + 105, + 216, + 505, + 230 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 505, + 230 + ], + "score": 1.0, + "content": "Jacob Andreas, Dan Klein, and Sergey Levine. Modular multitask reinforcement learning with", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 228, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 115, + 228, + 505, + 241 + ], + "score": 1.0, + "content": "policy sketches. In ICML, volume 70 of Proceedings of Machine Learning Research, pp. 166–", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 117, + 240, + 194, + 250 + ], + "spans": [ + { + "bbox": [ + 117, + 240, + 194, + 250 + ], + "score": 1.0, + "content": "175. PMLR, 2017.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 259, + 504, + 293 + ], + "lines": [ + { + "bbox": [ + 106, + 259, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 106, + 259, + 505, + 272 + ], + "score": 1.0, + "content": "Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 271, + 505, + 283 + ], + "spans": [ + { + "bbox": [ + 116, + 271, + 505, + 283 + ], + "score": 1.0, + "content": "McGrew, Josh Tobin, Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. CoRR,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 282, + 209, + 293 + ], + "spans": [ + { + "bbox": [ + 115, + 282, + 209, + 293 + ], + "score": 1.0, + "content": "abs/1707.01495, 2017.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 106, + 301, + 504, + 335 + ], + "lines": [ + { + "bbox": [ + 106, + 301, + 505, + 313 + ], + "spans": [ + { + "bbox": [ + 106, + 301, + 505, + 313 + ], + "score": 1.0, + "content": "Charles Blundell, Benigno Uria, Alexander Pritzel, Yazhe Li, Avraham Ruderman, Joel Z.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 115, + 312, + 505, + 325 + ], + "spans": [ + { + "bbox": [ + 115, + 312, + 505, + 325 + ], + "score": 1.0, + "content": "Leibo, Jack Rae, Daan Wierstra, and Demis Hassabis. Model-free episodic control. CoRR,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 324, + 209, + 335 + ], + "spans": [ + { + "bbox": [ + 115, + 324, + 209, + 335 + ], + "score": 1.0, + "content": "abs/1606.04460, 2016.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 106, + 343, + 505, + 378 + ], + "lines": [ + { + "bbox": [ + 106, + 343, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 106, + 343, + 505, + 357 + ], + "score": 1.0, + "content": "Craig Boutilier, Richard Dearden, and Moises Goldszmidt. Exploiting structure in policy construc-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 354, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 115, + 354, + 505, + 368 + ], + "score": 1.0, + "content": "tion. In Proceedings of the 14th International Joint Conference on Artificial Intelligence - Volume", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 366, + 504, + 378 + ], + "spans": [ + { + "bbox": [ + 115, + 366, + 504, + 378 + ], + "score": 1.0, + "content": "2, IJCAI’95, pp. 1104–1111, San Francisco, CA, USA, 1995. Morgan Kaufmann Publishers Inc.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 385, + 504, + 408 + ], + "lines": [ + { + "bbox": [ + 105, + 385, + 504, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 504, + 399 + ], + "score": 1.0, + "content": "Craig Boutilier, Richard Dearden, and Moises Goldszmidt. Stochastic dynamic programming with´", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 397, + 366, + 408 + ], + "spans": [ + { + "bbox": [ + 116, + 397, + 366, + 408 + ], + "score": 1.0, + "content": "factored representations. Artif. Intell., 121(1-2):49–107, 2000.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 106, + 416, + 504, + 439 + ], + "lines": [ + { + "bbox": [ + 105, + 416, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 505, + 429 + ], + "score": 1.0, + "content": "Misha Denil, Sergio Gomez Colmenarejo, Serkan Cabi, David Saxton, and Nando de Freitas. Pro-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 428, + 318, + 439 + ], + "spans": [ + { + "bbox": [ + 115, + 428, + 318, + 439 + ], + "score": 1.0, + "content": "grammable agents. CoRR, abs/1706.06383, 2017.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 105, + 447, + 503, + 471 + ], + "lines": [ + { + "bbox": [ + 105, + 447, + 504, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 504, + 461 + ], + "score": 1.0, + "content": "Thomas G. Dietterich. Hierarchical reinforcement learning with the maxq value function decompo-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 459, + 422, + 471 + ], + "spans": [ + { + "bbox": [ + 115, + 459, + 422, + 471 + ], + "score": 1.0, + "content": "sition. J. Artif. Int. Res., 13(1):227–303, November 2000. ISSN 1076-9757.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 108, + 479, + 504, + 513 + ], + "lines": [ + { + "bbox": [ + 106, + 478, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 478, + 506, + 492 + ], + "score": 1.0, + "content": "Carlos Diuk, Andre Cohen, and Michael L. Littman. An object-oriented representation for efficient", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 489, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 115, + 489, + 505, + 504 + ], + "score": 1.0, + "content": "reinforcement learning. In ICML, volume 307 of ACM International Conference Proceeding", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 116, + 501, + 253, + 513 + ], + "spans": [ + { + "bbox": [ + 116, + 501, + 253, + 513 + ], + "score": 1.0, + "content": "Series, pp. 240–247. ACM, 2008.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 520, + 505, + 555 + ], + "lines": [ + { + "bbox": [ + 106, + 520, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 520, + 505, + 534 + ], + "score": 1.0, + "content": "Kun Duan, Devi Parikh, David Crandall, and Kristen Grauman. Discovering localized attributes", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 116, + 532, + 504, + 544 + ], + "spans": [ + { + "bbox": [ + 116, + 532, + 504, + 544 + ], + "score": 1.0, + "content": "for fine-grained recognition. In IEEE Conference on Computer Vision and Pattern Recognition", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 543, + 178, + 555 + ], + "spans": [ + { + "bbox": [ + 116, + 543, + 178, + 555 + ], + "score": 1.0, + "content": "(CVPR), 2012.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 106, + 563, + 505, + 597 + ], + "lines": [ + { + "bbox": [ + 105, + 562, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 562, + 505, + 576 + ], + "score": 1.0, + "content": "Ali Farhadi, Ian Endres, Derek Hoiem, and David Forsyth. Describing objects by their attributes.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 573, + 505, + 587 + ], + "spans": [ + { + "bbox": [ + 115, + 573, + 505, + 587 + ], + "score": 1.0, + "content": "In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 1778–", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 117, + 585, + 192, + 596 + ], + "spans": [ + { + "bbox": [ + 117, + 585, + 192, + 596 + ], + "score": 1.0, + "content": "1785. IEEE, 2009.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 106, + 605, + 504, + 639 + ], + "lines": [ + { + "bbox": [ + 105, + 604, + 505, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 505, + 619 + ], + "score": 1.0, + "content": "Carlos Guestrin, Daphne Koller, Chris Gearhart, and Neal Kanodia. Generalizing plans to new", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 116, + 617, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 116, + 617, + 505, + 629 + ], + "score": 1.0, + "content": "environments in relational mdps. In Proceedings of the 18th International Joint Conference on", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 627, + 343, + 640 + ], + "spans": [ + { + "bbox": [ + 116, + 627, + 343, + 640 + ], + "score": 1.0, + "content": "Artificial Intelligence, IJCAI’03, pp. 1003–1010, 2003a.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 105, + 647, + 504, + 670 + ], + "lines": [ + { + "bbox": [ + 106, + 647, + 504, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 647, + 504, + 660 + ], + "score": 1.0, + "content": "Carlos Guestrin, Daphne Koller, Ronald Parr, and Shobha Venkataraman. Efficient solution algo-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 117, + 658, + 384, + 670 + ], + "spans": [ + { + "bbox": [ + 117, + 658, + 384, + 670 + ], + "score": 1.0, + "content": "rithms for factored mdps. J. Artif. Intell. Res., 19:399–468, 2003b.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5 + }, + { + "type": "text", + "bbox": [ + 106, + 678, + 503, + 701 + ], + "lines": [ + { + "bbox": [ + 105, + 677, + 505, + 692 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 692 + ], + "score": 1.0, + "content": "Natalia Hernandez-Gardiol and Leslie Pack Kaelbling. Envelope-based planning in relational mdps.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 116, + 689, + 279, + 702 + ], + "spans": [ + { + "bbox": [ + 116, + 689, + 279, + 702 + ], + "score": 1.0, + "content": "In NIPS, pp. 783–790. MIT Press, 2003.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5 + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 504, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 504, + 723 + ], + "score": 1.0, + "content": "David Isele, Mohammad Rostami, and Eric Eaton. Using task features for zero-shot knowledge", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 116, + 720, + 442, + 732 + ], + "spans": [ + { + "bbox": [ + 116, + 720, + 442, + 732 + ], + "score": 1.0, + "content": "transfer in lifelong learning. In IJCAI, pp. 1620–1626. IJCAI/AAAI Press, 2016.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "10", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 176, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 176, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 176, + 95 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 100, + 505, + 133 + ], + "lines": [ + { + "bbox": [ + 105, + 99, + 505, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 505, + 113 + ], + "score": 1.0, + "content": "David Abel, D. Ellis Hershkowitz, Gabriel Barth-Maron, Stephen Brawner, Kevin O’Farrell, James", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 114, + 110, + 506, + 125 + ], + "spans": [ + { + "bbox": [ + 114, + 110, + 506, + 125 + ], + "score": 1.0, + "content": "MacGlashan, and Stefanie Tellex. Goal-based action priors. In ICAPS, pp. 306–314. AAAI Press,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 114, + 120, + 143, + 135 + ], + "spans": [ + { + "bbox": [ + 114, + 120, + 143, + 135 + ], + "score": 1.0, + "content": "2015.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2, + "bbox_fs": [ + 105, + 99, + 506, + 135 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 142, + 569, + 209 + ], + "lines": [ + { + "bbox": [ + 105, + 141, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 105, + 141, + 505, + 155 + ], + "score": 1.0, + "content": "Pulkit Agrawal, Ashvin V Nair, Pieter Abbeel, Jitendra Malik, and Sergey Levine. Learning to poke", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 114, + 153, + 505, + 168 + ], + "spans": [ + { + "bbox": [ + 114, + 153, + 505, + 168 + ], + "score": 1.0, + "content": "by poking: Experiential learning of intuitive physics. In D. D. Lee, M. Sugiyama, U. V. Luxburg,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 114, + 163, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 114, + 163, + 505, + 177 + ], + "score": 1.0, + "content": "I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 174, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 115, + 174, + 505, + 189 + ], + "score": 1.0, + "content": "pp. 5074–5082. Curran Associates, Inc., 2016. URL http://papers.nips.cc/paper/", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 186, + 572, + 199 + ], + "spans": [ + { + "bbox": [ + 115, + 186, + 572, + 199 + ], + "score": 1.0, + "content": "6113-learning-to-poke-by-poking-experiential-learning-of-intuitive-physics.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 114, + 198, + 140, + 209 + ], + "spans": [ + { + "bbox": [ + 114, + 198, + 140, + 209 + ], + "score": 1.0, + "content": "pdf.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6.5, + "bbox_fs": [ + 105, + 141, + 572, + 209 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 217, + 507, + 251 + ], + "lines": [ + { + "bbox": [ + 105, + 216, + 505, + 230 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 505, + 230 + ], + "score": 1.0, + "content": "Jacob Andreas, Dan Klein, and Sergey Levine. Modular multitask reinforcement learning with", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 228, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 115, + 228, + 505, + 241 + ], + "score": 1.0, + "content": "policy sketches. In ICML, volume 70 of Proceedings of Machine Learning Research, pp. 166–", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 117, + 240, + 194, + 250 + ], + "spans": [ + { + "bbox": [ + 117, + 240, + 194, + 250 + ], + "score": 1.0, + "content": "175. PMLR, 2017.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11, + "bbox_fs": [ + 105, + 216, + 505, + 250 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 259, + 504, + 293 + ], + "lines": [ + { + "bbox": [ + 106, + 259, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 106, + 259, + 505, + 272 + ], + "score": 1.0, + "content": "Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 271, + 505, + 283 + ], + "spans": [ + { + "bbox": [ + 116, + 271, + 505, + 283 + ], + "score": 1.0, + "content": "McGrew, Josh Tobin, Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. CoRR,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 282, + 209, + 293 + ], + "spans": [ + { + "bbox": [ + 115, + 282, + 209, + 293 + ], + "score": 1.0, + "content": "abs/1707.01495, 2017.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14, + "bbox_fs": [ + 106, + 259, + 505, + 293 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 301, + 504, + 335 + ], + "lines": [ + { + "bbox": [ + 106, + 301, + 505, + 313 + ], + "spans": [ + { + "bbox": [ + 106, + 301, + 505, + 313 + ], + "score": 1.0, + "content": "Charles Blundell, Benigno Uria, Alexander Pritzel, Yazhe Li, Avraham Ruderman, Joel Z.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 115, + 312, + 505, + 325 + ], + "spans": [ + { + "bbox": [ + 115, + 312, + 505, + 325 + ], + "score": 1.0, + "content": "Leibo, Jack Rae, Daan Wierstra, and Demis Hassabis. Model-free episodic control. CoRR,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 324, + 209, + 335 + ], + "spans": [ + { + "bbox": [ + 115, + 324, + 209, + 335 + ], + "score": 1.0, + "content": "abs/1606.04460, 2016.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17, + "bbox_fs": [ + 106, + 301, + 505, + 335 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 343, + 505, + 378 + ], + "lines": [ + { + "bbox": [ + 106, + 343, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 106, + 343, + 505, + 357 + ], + "score": 1.0, + "content": "Craig Boutilier, Richard Dearden, and Moises Goldszmidt. Exploiting structure in policy construc-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 354, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 115, + 354, + 505, + 368 + ], + "score": 1.0, + "content": "tion. In Proceedings of the 14th International Joint Conference on Artificial Intelligence - Volume", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 366, + 504, + 378 + ], + "spans": [ + { + "bbox": [ + 115, + 366, + 504, + 378 + ], + "score": 1.0, + "content": "2, IJCAI’95, pp. 1104–1111, San Francisco, CA, USA, 1995. Morgan Kaufmann Publishers Inc.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20, + "bbox_fs": [ + 106, + 343, + 505, + 378 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 385, + 504, + 408 + ], + "lines": [ + { + "bbox": [ + 105, + 385, + 504, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 504, + 399 + ], + "score": 1.0, + "content": "Craig Boutilier, Richard Dearden, and Moises Goldszmidt. Stochastic dynamic programming with´", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 397, + 366, + 408 + ], + "spans": [ + { + "bbox": [ + 116, + 397, + 366, + 408 + ], + "score": 1.0, + "content": "factored representations. Artif. Intell., 121(1-2):49–107, 2000.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 385, + 504, + 408 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 416, + 504, + 439 + ], + "lines": [ + { + "bbox": [ + 105, + 416, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 505, + 429 + ], + "score": 1.0, + "content": "Misha Denil, Sergio Gomez Colmenarejo, Serkan Cabi, David Saxton, and Nando de Freitas. Pro-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 428, + 318, + 439 + ], + "spans": [ + { + "bbox": [ + 115, + 428, + 318, + 439 + ], + "score": 1.0, + "content": "grammable agents. CoRR, abs/1706.06383, 2017.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5, + "bbox_fs": [ + 105, + 416, + 505, + 439 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 447, + 503, + 471 + ], + "lines": [ + { + "bbox": [ + 105, + 447, + 504, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 504, + 461 + ], + "score": 1.0, + "content": "Thomas G. Dietterich. Hierarchical reinforcement learning with the maxq value function decompo-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 459, + 422, + 471 + ], + "spans": [ + { + "bbox": [ + 115, + 459, + 422, + 471 + ], + "score": 1.0, + "content": "sition. J. Artif. Int. Res., 13(1):227–303, November 2000. ISSN 1076-9757.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 447, + 504, + 471 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 479, + 504, + 513 + ], + "lines": [ + { + "bbox": [ + 106, + 478, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 478, + 506, + 492 + ], + "score": 1.0, + "content": "Carlos Diuk, Andre Cohen, and Michael L. Littman. An object-oriented representation for efficient", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 489, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 115, + 489, + 505, + 504 + ], + "score": 1.0, + "content": "reinforcement learning. In ICML, volume 307 of ACM International Conference Proceeding", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 116, + 501, + 253, + 513 + ], + "spans": [ + { + "bbox": [ + 116, + 501, + 253, + 513 + ], + "score": 1.0, + "content": "Series, pp. 240–247. ACM, 2008.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29, + "bbox_fs": [ + 106, + 478, + 506, + 513 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 520, + 505, + 555 + ], + "lines": [ + { + "bbox": [ + 106, + 520, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 520, + 505, + 534 + ], + "score": 1.0, + "content": "Kun Duan, Devi Parikh, David Crandall, and Kristen Grauman. Discovering localized attributes", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 116, + 532, + 504, + 544 + ], + "spans": [ + { + "bbox": [ + 116, + 532, + 504, + 544 + ], + "score": 1.0, + "content": "for fine-grained recognition. In IEEE Conference on Computer Vision and Pattern Recognition", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 543, + 178, + 555 + ], + "spans": [ + { + "bbox": [ + 116, + 543, + 178, + 555 + ], + "score": 1.0, + "content": "(CVPR), 2012.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32, + "bbox_fs": [ + 106, + 520, + 505, + 555 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 563, + 505, + 597 + ], + "lines": [ + { + "bbox": [ + 105, + 562, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 562, + 505, + 576 + ], + "score": 1.0, + "content": "Ali Farhadi, Ian Endres, Derek Hoiem, and David Forsyth. Describing objects by their attributes.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 573, + 505, + 587 + ], + "spans": [ + { + "bbox": [ + 115, + 573, + 505, + 587 + ], + "score": 1.0, + "content": "In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 1778–", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 117, + 585, + 192, + 596 + ], + "spans": [ + { + "bbox": [ + 117, + 585, + 192, + 596 + ], + "score": 1.0, + "content": "1785. IEEE, 2009.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 562, + 505, + 596 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 605, + 504, + 639 + ], + "lines": [ + { + "bbox": [ + 105, + 604, + 505, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 505, + 619 + ], + "score": 1.0, + "content": "Carlos Guestrin, Daphne Koller, Chris Gearhart, and Neal Kanodia. Generalizing plans to new", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 116, + 617, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 116, + 617, + 505, + 629 + ], + "score": 1.0, + "content": "environments in relational mdps. In Proceedings of the 18th International Joint Conference on", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 627, + 343, + 640 + ], + "spans": [ + { + "bbox": [ + 116, + 627, + 343, + 640 + ], + "score": 1.0, + "content": "Artificial Intelligence, IJCAI’03, pp. 1003–1010, 2003a.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 604, + 505, + 640 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 647, + 504, + 670 + ], + "lines": [ + { + "bbox": [ + 106, + 647, + 504, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 647, + 504, + 660 + ], + "score": 1.0, + "content": "Carlos Guestrin, Daphne Koller, Ronald Parr, and Shobha Venkataraman. Efficient solution algo-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 117, + 658, + 384, + 670 + ], + "spans": [ + { + "bbox": [ + 117, + 658, + 384, + 670 + ], + "score": 1.0, + "content": "rithms for factored mdps. J. Artif. Intell. Res., 19:399–468, 2003b.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5, + "bbox_fs": [ + 106, + 647, + 504, + 670 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 678, + 503, + 701 + ], + "lines": [ + { + "bbox": [ + 105, + 677, + 505, + 692 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 692 + ], + "score": 1.0, + "content": "Natalia Hernandez-Gardiol and Leslie Pack Kaelbling. Envelope-based planning in relational mdps.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 116, + 689, + 279, + 702 + ], + "spans": [ + { + "bbox": [ + 116, + 689, + 279, + 702 + ], + "score": 1.0, + "content": "In NIPS, pp. 783–790. MIT Press, 2003.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5, + "bbox_fs": [ + 105, + 677, + 505, + 702 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 504, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 504, + 723 + ], + "score": 1.0, + "content": "David Isele, Mohammad Rostami, and Eric Eaton. Using task features for zero-shot knowledge", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 116, + 720, + 442, + 732 + ], + "spans": [ + { + "bbox": [ + 116, + 720, + 442, + 732 + ], + "score": 1.0, + "content": "transfer in lifelong learning. In IJCAI, pp. 1620–1626. IJCAI/AAAI Press, 2016.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5, + "bbox_fs": [ + 105, + 708, + 504, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 104, + 69, + 506, + 745 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 506, + 97 + ], + "score": 1.0, + "content": "Tejas D. Kulkarni, Karthik Narasimhan, Ardavan Saeedi, and Josh Tenenbaum. Hierarchical deep", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 113, + 91, + 506, + 109 + ], + "spans": [ + { + "bbox": [ + 113, + 91, + 506, + 109 + ], + "score": 1.0, + "content": "reinforcement learning: Integrating temporal abstraction and intrinsic motivation. In NIPS, pp.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 116, + 105, + 192, + 117 + ], + "spans": [ + { + "bbox": [ + 116, + 105, + 192, + 117 + ], + "score": 1.0, + "content": "3675–3683, 2016.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 123, + 506, + 137 + ], + "spans": [ + { + "bbox": [ + 105, + 123, + 506, + 137 + ], + "score": 1.0, + "content": "Christoph H Lampert, Hannes Nickisch, and Stefan Harmeling. Learning to detect unseen object", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 114, + 133, + 505, + 148 + ], + "spans": [ + { + "bbox": [ + 114, + 133, + 505, + 148 + ], + "score": 1.0, + "content": "classes by between-class attribute transfer. In Computer Vision and Pattern Recognition, 2009.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 144, + 362, + 158 + ], + "spans": [ + { + "bbox": [ + 115, + 144, + 362, + 158 + ], + "score": 1.0, + "content": "CVPR 2009. IEEE Conference on, pp. 951–958. IEEE, 2009.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 161, + 505, + 179 + ], + "spans": [ + { + "bbox": [ + 104, + 161, + 505, + 179 + ], + "score": 1.0, + "content": "David Lopez-Paz and Marc’Aurelio Ranzato. Gradient episodic memory for continuum learning.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 114, + 174, + 240, + 189 + ], + "spans": [ + { + "bbox": [ + 114, + 174, + 240, + 189 + ], + "score": 1.0, + "content": "CoRR, abs/1706.08840, 2017.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 193, + 506, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 506, + 207 + ], + "score": 1.0, + "content": "Marlos C. Machado, Marc G. Bellemare, and Michael H. Bowling. A laplacian framework for option", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 113, + 202, + 506, + 219 + ], + "spans": [ + { + "bbox": [ + 113, + 202, + 506, + 219 + ], + "score": 1.0, + "content": "discovery in reinforcement learning. In ICML, volume 70 of Proceedings of Machine Learning", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 116, + 216, + 280, + 228 + ], + "spans": [ + { + "bbox": [ + 116, + 216, + 280, + 228 + ], + "score": 1.0, + "content": "Research, pp. 2295–2304. PMLR, 2017.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 107, + 234, + 504, + 246 + ], + "spans": [ + { + "bbox": [ + 107, + 234, + 504, + 246 + ], + "score": 1.0, + "content": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Belle-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 114, + 245, + 506, + 259 + ], + "spans": [ + { + "bbox": [ + 114, + 245, + 506, + 259 + ], + "score": 1.0, + "content": "mare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 257, + 505, + 268 + ], + "spans": [ + { + "bbox": [ + 116, + 257, + 505, + 268 + ], + "score": 1.0, + "content": "Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wier-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 114, + 265, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 114, + 265, + 505, + 282 + ], + "score": 1.0, + "content": "stra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 277, + 297, + 291 + ], + "spans": [ + { + "bbox": [ + 115, + 277, + 297, + 291 + ], + "score": 1.0, + "content": "Nature, 518(7540):529–533, February 2015.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 296, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 106, + 296, + 506, + 310 + ], + "score": 1.0, + "content": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 115, + 307, + 507, + 321 + ], + "spans": [ + { + "bbox": [ + 115, + 307, + 507, + 321 + ], + "score": 1.0, + "content": "Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 318, + 450, + 332 + ], + "spans": [ + { + "bbox": [ + 115, + 318, + 450, + 332 + ], + "score": 1.0, + "content": "learning. In International Conference on Machine Learning, pp. 1928–1937, 2016.", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 336, + 506, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 506, + 351 + ], + "score": 1.0, + "content": "Junhyuk Oh, Satinder P. Singh, Honglak Lee, and Pushmeet Kohli. Zero-shot task generalization", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 348, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 115, + 348, + 505, + 362 + ], + "score": 1.0, + "content": "with multi-task deep reinforcement learning. In ICML, volume 70 of Proceedings of Machine", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 114, + 357, + 319, + 373 + ], + "spans": [ + { + "bbox": [ + 114, + 357, + 319, + 373 + ], + "score": 1.0, + "content": "Learning Research, pp. 2661–2670. PMLR, 2017.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 376, + 505, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 505, + 391 + ], + "score": 1.0, + "content": "Devi Parikh and Kristen Grauman. Relative attributes. In Computer Vision (ICCV), 2011 IEEE", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 114, + 389, + 342, + 403 + ], + "spans": [ + { + "bbox": [ + 114, + 389, + 342, + 403 + ], + "score": 1.0, + "content": "International Conference on, pp. 503–510. IEEE, 2011.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 406, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 505, + 420 + ], + "score": 1.0, + "content": "Ronald Parr and Stuart Russell. Reinforcement learning with hierarchies of machines. In Proceed-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 114, + 417, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 114, + 417, + 506, + 432 + ], + "score": 1.0, + "content": "ings of the 1997 Conference on Advances in Neural Information Processing Systems 10, NIPS", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 117, + 429, + 457, + 443 + ], + "spans": [ + { + "bbox": [ + 117, + 429, + 457, + 443 + ], + "score": 1.0, + "content": "’97, pp. 1043–1049, Cambridge, MA, USA, 1998. MIT Press. ISBN 0-262-10076-2.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 446, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 505, + 460 + ], + "score": 1.0, + "content": "Alexander Pritzel, Benigno Uria, Sriram Srinivasan, Adria Puigdom ` enech Badia, Oriol Vinyals, `", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 114, + 457, + 505, + 473 + ], + "spans": [ + { + "bbox": [ + 114, + 457, + 505, + 473 + ], + "score": 1.0, + "content": "Demis Hassabis, Daan Wierstra, and Charles Blundell. Neural episodic control. In Proceedings", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 469, + 505, + 483 + ], + "spans": [ + { + "bbox": [ + 115, + 469, + 505, + 483 + ], + "score": 1.0, + "content": "of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 114, + 480, + 282, + 495 + ], + "spans": [ + { + "bbox": [ + 114, + 480, + 282, + 495 + ], + "score": 1.0, + "content": "6-11 August 2017, pp. 2827–2836, 2017.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 500, + 504, + 511 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 504, + 511 + ], + "score": 1.0, + "content": "Scott E. Reed and Nando de Freitas. Neural programmer-interpreters. CoRR, abs/1511.06279, 2015.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 518, + 505, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 518, + 505, + 532 + ], + "score": 1.0, + "content": "Tom Schaul, Daniel Horgan, Karol Gregor, and David Silver. Universal Value Function Approxi-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 114, + 528, + 414, + 543 + ], + "spans": [ + { + "bbox": [ + 114, + 528, + 414, + 543 + ], + "score": 1.0, + "content": "mators. In International Conference on Machine Learning (ICML), 2015.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 546, + 506, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 506, + 561 + ], + "score": 1.0, + "content": "David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 114, + 557, + 506, + 572 + ], + "spans": [ + { + "bbox": [ + 114, + 557, + 506, + 572 + ], + "score": 1.0, + "content": "Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, Sander Dieleman,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 115, + 570, + 505, + 582 + ], + "spans": [ + { + "bbox": [ + 115, + 570, + 505, + 582 + ], + "score": 1.0, + "content": "Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy Lillicrap, Madeleine", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 114, + 581, + 506, + 595 + ], + "spans": [ + { + "bbox": [ + 114, + 581, + 506, + 595 + ], + "score": 1.0, + "content": "Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of Go with", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 114, + 590, + 444, + 604 + ], + "spans": [ + { + "bbox": [ + 114, + 590, + 444, + 604 + ], + "score": 1.0, + "content": "deep neural networks and tree search. Nature, 529(7587):484–489, January 2016.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 609, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 505, + 623 + ], + "score": 1.0, + "content": "Sainbayar Sukhbaatar, Arthur Szlam, Gabriel Synnaeve, Soumith Chintala, and Rob Fergus. Maze-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 114, + 621, + 450, + 635 + ], + "spans": [ + { + "bbox": [ + 114, + 621, + 450, + 635 + ], + "score": 1.0, + "content": "base: A sandbox for learning from games. arXiv preprint arXiv:1511.07401, 2015.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 639, + 506, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 506, + 653 + ], + "score": 1.0, + "content": "Richard Sutton, Doina Precup, and Satinder Singh. Between mdps and semi-mdps: A framework", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 114, + 650, + 494, + 664 + ], + "spans": [ + { + "bbox": [ + 114, + 650, + 494, + 664 + ], + "score": 1.0, + "content": "for temporal abstraction in reinforcement learning. Artificial Intelligence, 112:181–211, 1999.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 668, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 505, + 683 + ], + "score": 1.0, + "content": "Richard S. Sutton, Joseph Modayil, Michael Delp, Thomas Degris, Patrick M. Pilarski, Adam White,", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 114, + 680, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 114, + 680, + 505, + 694 + ], + "score": 1.0, + "content": "and Doina Precup. Horde: a scalable real-time architecture for learning knowledge from unsu-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 113, + 690, + 433, + 705 + ], + "spans": [ + { + "bbox": [ + 113, + 690, + 433, + 705 + ], + "score": 1.0, + "content": "pervised sensorimotor interaction. In AAMAS, pp. 761–768. IFAAMAS, 2011.", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "Chen Tessler, Shahar Givony, Tom Zahavy, Daniel J. Mankowitz, and Shie Mannor. A deep hierar-", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 114, + 721, + 496, + 735 + ], + "spans": [ + { + "bbox": [ + 114, + 721, + 496, + 735 + ], + "score": 1.0, + "content": "chical approach to lifelong learning in minecraft. In AAAI, pp. 1553–1561. AAAI Press, 2017.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 23.5 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 13 + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 104, + 69, + 506, + 745 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 506, + 97 + ], + "score": 1.0, + "content": "Tejas D. Kulkarni, Karthik Narasimhan, Ardavan Saeedi, and Josh Tenenbaum. Hierarchical deep", + "type": "text" + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 91, + 506, + 109 + ], + "spans": [ + { + "bbox": [ + 113, + 91, + 506, + 109 + ], + "score": 1.0, + "content": "reinforcement learning: Integrating temporal abstraction and intrinsic motivation. In NIPS, pp.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 116, + 105, + 192, + 117 + ], + "spans": [ + { + "bbox": [ + 116, + 105, + 192, + 117 + ], + "score": 1.0, + "content": "3675–3683, 2016.", + "type": "text" + } + ], + "index": 2, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 123, + 506, + 137 + ], + "spans": [ + { + "bbox": [ + 105, + 123, + 506, + 137 + ], + "score": 1.0, + "content": "Christoph H Lampert, Hannes Nickisch, and Stefan Harmeling. Learning to detect unseen object", + "type": "text" + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 133, + 505, + 148 + ], + "spans": [ + { + "bbox": [ + 114, + 133, + 505, + 148 + ], + "score": 1.0, + "content": "classes by between-class attribute transfer. In Computer Vision and Pattern Recognition, 2009.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 144, + 362, + 158 + ], + "spans": [ + { + "bbox": [ + 115, + 144, + 362, + 158 + ], + "score": 1.0, + "content": "CVPR 2009. IEEE Conference on, pp. 951–958. IEEE, 2009.", + "type": "text" + } + ], + "index": 5, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 161, + 505, + 179 + ], + "spans": [ + { + "bbox": [ + 104, + 161, + 505, + 179 + ], + "score": 1.0, + "content": "David Lopez-Paz and Marc’Aurelio Ranzato. Gradient episodic memory for continuum learning.", + "type": "text" + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 174, + 240, + 189 + ], + "spans": [ + { + "bbox": [ + 114, + 174, + 240, + 189 + ], + "score": 1.0, + "content": "CoRR, abs/1706.08840, 2017.", + "type": "text" + } + ], + "index": 7, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 193, + 506, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 506, + 207 + ], + "score": 1.0, + "content": "Marlos C. Machado, Marc G. Bellemare, and Michael H. Bowling. A laplacian framework for option", + "type": "text" + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 202, + 506, + 219 + ], + "spans": [ + { + "bbox": [ + 113, + 202, + 506, + 219 + ], + "score": 1.0, + "content": "discovery in reinforcement learning. In ICML, volume 70 of Proceedings of Machine Learning", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 116, + 216, + 280, + 228 + ], + "spans": [ + { + "bbox": [ + 116, + 216, + 280, + 228 + ], + "score": 1.0, + "content": "Research, pp. 2295–2304. PMLR, 2017.", + "type": "text" + } + ], + "index": 10, + "is_list_end_line": true + }, + { + "bbox": [ + 107, + 234, + 504, + 246 + ], + "spans": [ + { + "bbox": [ + 107, + 234, + 504, + 246 + ], + "score": 1.0, + "content": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Belle-", + "type": "text" + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 245, + 506, + 259 + ], + "spans": [ + { + "bbox": [ + 114, + 245, + 506, + 259 + ], + "score": 1.0, + "content": "mare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 257, + 505, + 268 + ], + "spans": [ + { + "bbox": [ + 116, + 257, + 505, + 268 + ], + "score": 1.0, + "content": "Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wier-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 114, + 265, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 114, + 265, + 505, + 282 + ], + "score": 1.0, + "content": "stra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 277, + 297, + 291 + ], + "spans": [ + { + "bbox": [ + 115, + 277, + 297, + 291 + ], + "score": 1.0, + "content": "Nature, 518(7540):529–533, February 2015.", + "type": "text" + } + ], + "index": 15, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 296, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 106, + 296, + 506, + 310 + ], + "score": 1.0, + "content": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim", + "type": "text" + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 307, + 507, + 321 + ], + "spans": [ + { + "bbox": [ + 115, + 307, + 507, + 321 + ], + "score": 1.0, + "content": "Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 318, + 450, + 332 + ], + "spans": [ + { + "bbox": [ + 115, + 318, + 450, + 332 + ], + "score": 1.0, + "content": "learning. In International Conference on Machine Learning, pp. 1928–1937, 2016.", + "type": "text" + } + ], + "index": 18, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 336, + 506, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 506, + 351 + ], + "score": 1.0, + "content": "Junhyuk Oh, Satinder P. Singh, Honglak Lee, and Pushmeet Kohli. Zero-shot task generalization", + "type": "text" + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 348, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 115, + 348, + 505, + 362 + ], + "score": 1.0, + "content": "with multi-task deep reinforcement learning. In ICML, volume 70 of Proceedings of Machine", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 114, + 357, + 319, + 373 + ], + "spans": [ + { + "bbox": [ + 114, + 357, + 319, + 373 + ], + "score": 1.0, + "content": "Learning Research, pp. 2661–2670. PMLR, 2017.", + "type": "text" + } + ], + "index": 21, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 376, + 505, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 505, + 391 + ], + "score": 1.0, + "content": "Devi Parikh and Kristen Grauman. Relative attributes. In Computer Vision (ICCV), 2011 IEEE", + "type": "text" + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 389, + 342, + 403 + ], + "spans": [ + { + "bbox": [ + 114, + 389, + 342, + 403 + ], + "score": 1.0, + "content": "International Conference on, pp. 503–510. IEEE, 2011.", + "type": "text" + } + ], + "index": 23, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 406, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 505, + 420 + ], + "score": 1.0, + "content": "Ronald Parr and Stuart Russell. Reinforcement learning with hierarchies of machines. In Proceed-", + "type": "text" + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 417, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 114, + 417, + 506, + 432 + ], + "score": 1.0, + "content": "ings of the 1997 Conference on Advances in Neural Information Processing Systems 10, NIPS", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 117, + 429, + 457, + 443 + ], + "spans": [ + { + "bbox": [ + 117, + 429, + 457, + 443 + ], + "score": 1.0, + "content": "’97, pp. 1043–1049, Cambridge, MA, USA, 1998. MIT Press. ISBN 0-262-10076-2.", + "type": "text" + } + ], + "index": 26, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 446, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 505, + 460 + ], + "score": 1.0, + "content": "Alexander Pritzel, Benigno Uria, Sriram Srinivasan, Adria Puigdom ` enech Badia, Oriol Vinyals, `", + "type": "text" + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 457, + 505, + 473 + ], + "spans": [ + { + "bbox": [ + 114, + 457, + 505, + 473 + ], + "score": 1.0, + "content": "Demis Hassabis, Daan Wierstra, and Charles Blundell. Neural episodic control. In Proceedings", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 469, + 505, + 483 + ], + "spans": [ + { + "bbox": [ + 115, + 469, + 505, + 483 + ], + "score": 1.0, + "content": "of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 114, + 480, + 282, + 495 + ], + "spans": [ + { + "bbox": [ + 114, + 480, + 282, + 495 + ], + "score": 1.0, + "content": "6-11 August 2017, pp. 2827–2836, 2017.", + "type": "text" + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 500, + 504, + 511 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 504, + 511 + ], + "score": 1.0, + "content": "Scott E. Reed and Nando de Freitas. Neural programmer-interpreters. CoRR, abs/1511.06279, 2015.", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 106, + 518, + 505, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 518, + 505, + 532 + ], + "score": 1.0, + "content": "Tom Schaul, Daniel Horgan, Karol Gregor, and David Silver. Universal Value Function Approxi-", + "type": "text" + } + ], + "index": 32, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 528, + 414, + 543 + ], + "spans": [ + { + "bbox": [ + 114, + 528, + 414, + 543 + ], + "score": 1.0, + "content": "mators. In International Conference on Machine Learning (ICML), 2015.", + "type": "text" + } + ], + "index": 33, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 546, + 506, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 506, + 561 + ], + "score": 1.0, + "content": "David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche,", + "type": "text" + } + ], + "index": 34, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 557, + 506, + 572 + ], + "spans": [ + { + "bbox": [ + 114, + 557, + 506, + 572 + ], + "score": 1.0, + "content": "Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, Sander Dieleman,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 115, + 570, + 505, + 582 + ], + "spans": [ + { + "bbox": [ + 115, + 570, + 505, + 582 + ], + "score": 1.0, + "content": "Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy Lillicrap, Madeleine", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 114, + 581, + 506, + 595 + ], + "spans": [ + { + "bbox": [ + 114, + 581, + 506, + 595 + ], + "score": 1.0, + "content": "Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of Go with", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 114, + 590, + 444, + 604 + ], + "spans": [ + { + "bbox": [ + 114, + 590, + 444, + 604 + ], + "score": 1.0, + "content": "deep neural networks and tree search. Nature, 529(7587):484–489, January 2016.", + "type": "text" + } + ], + "index": 38, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 609, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 505, + 623 + ], + "score": 1.0, + "content": "Sainbayar Sukhbaatar, Arthur Szlam, Gabriel Synnaeve, Soumith Chintala, and Rob Fergus. Maze-", + "type": "text" + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 621, + 450, + 635 + ], + "spans": [ + { + "bbox": [ + 114, + 621, + 450, + 635 + ], + "score": 1.0, + "content": "base: A sandbox for learning from games. arXiv preprint arXiv:1511.07401, 2015.", + "type": "text" + } + ], + "index": 40, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 639, + 506, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 506, + 653 + ], + "score": 1.0, + "content": "Richard Sutton, Doina Precup, and Satinder Singh. Between mdps and semi-mdps: A framework", + "type": "text" + } + ], + "index": 41, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 650, + 494, + 664 + ], + "spans": [ + { + "bbox": [ + 114, + 650, + 494, + 664 + ], + "score": 1.0, + "content": "for temporal abstraction in reinforcement learning. Artificial Intelligence, 112:181–211, 1999.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 668, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 505, + 683 + ], + "score": 1.0, + "content": "Richard S. Sutton, Joseph Modayil, Michael Delp, Thomas Degris, Patrick M. Pilarski, Adam White,", + "type": "text" + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 680, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 114, + 680, + 505, + 694 + ], + "score": 1.0, + "content": "and Doina Precup. Horde: a scalable real-time architecture for learning knowledge from unsu-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 113, + 690, + 433, + 705 + ], + "spans": [ + { + "bbox": [ + 113, + 690, + 433, + 705 + ], + "score": 1.0, + "content": "pervised sensorimotor interaction. In AAMAS, pp. 761–768. IFAAMAS, 2011.", + "type": "text" + } + ], + "index": 45, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "Chen Tessler, Shahar Givony, Tom Zahavy, Daniel J. Mankowitz, and Shie Mannor. A deep hierar-", + "type": "text" + } + ], + "index": 46, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 721, + 496, + 735 + ], + "spans": [ + { + "bbox": [ + 114, + 721, + 496, + 735 + ], + "score": 1.0, + "content": "chical approach to lifelong learning in minecraft. In AAAI, pp. 1553–1561. AAAI Press, 2017.", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "Valentin Thomas, Jules Pondard, Emmanuel Bengio, Marc Sarfati, Philippe Beaudoin, Marie-Jean", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 93, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 115, + 93, + 505, + 107 + ], + "score": 1.0, + "content": "Meurs, Joelle Pineau, Doina Precup, and Yoshua Bengio. Independently controllable factors.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 117, + 105, + 452, + 117 + ], + "spans": [ + { + "bbox": [ + 117, + 105, + 452, + 117 + ], + "score": 1.0, + "content": "CoRR, abs/1708.01289, 2017. URL http://arxiv.org/abs/1708.01289.", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 121, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 104, + 121, + 505, + 136 + ], + "score": 1.0, + "content": "Sebastian Thrun and Anton Schwartz. Finding structure in reinforcement learning. In NIPS, pp.", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 133, + 228, + 145 + ], + "spans": [ + { + "bbox": [ + 116, + 133, + 228, + 145 + ], + "score": 1.0, + "content": "385–392. MIT Press, 1994.", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 151, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 505, + 163 + ], + "score": 1.0, + "content": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control.", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 161, + 270, + 173 + ], + "spans": [ + { + "bbox": [ + 115, + 161, + 270, + 173 + ], + "score": 1.0, + "content": "In IROS, pp. 5026–5033. IEEE, 2012.", + "type": "text", + "cross_page": true + } + ], + "index": 6, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 179, + 505, + 191 + ], + "spans": [ + { + "bbox": [ + 105, + 179, + 505, + 191 + ], + "score": 1.0, + "content": "M. van Otterlo. A Survey of Reinforcement Learning in Relational Domains. Number 31 in TR-", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 189, + 506, + 203 + ], + "spans": [ + { + "bbox": [ + 115, + 189, + 506, + 203 + ], + "score": 1.0, + "content": "CTIT-05, ISSN 1381-3625. Centre for Telematics and Information Technology University of", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 116, + 200, + 176, + 213 + ], + "spans": [ + { + "bbox": [ + 116, + 200, + 176, + 213 + ], + "score": 1.0, + "content": "Twente, 2005.", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 218, + 505, + 231 + ], + "spans": [ + { + "bbox": [ + 105, + 218, + 505, + 231 + ], + "score": 1.0, + "content": "Harm van Seijen, Mehdi Fatemi, Joshua Romoff, Romain Laroche, Tavian Barnes, and Jeffrey", + "type": "text", + "cross_page": true + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 230, + 490, + 243 + ], + "spans": [ + { + "bbox": [ + 116, + 230, + 490, + 243 + ], + "score": 1.0, + "content": "Tsang. Hybrid reward architecture for reinforcement learning. CoRR, abs/1706.04208, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 246, + 506, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 506, + 261 + ], + "score": 1.0, + "content": "Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement", + "type": "text", + "cross_page": true + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 258, + 325, + 271 + ], + "spans": [ + { + "bbox": [ + 116, + 258, + 325, + 271 + ], + "score": 1.0, + "content": "learning. In Machine Learning, pp. 229–256, 1992.", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 274, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 274, + 505, + 289 + ], + "score": 1.0, + "content": "Ning Zhang, Manohar Paluri, Marc’Aurelio Ranzato, Trevor Darrell, and Lubomir Bourdev. Panda:", + "type": "text", + "cross_page": true + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 286, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 115, + 286, + 506, + 299 + ], + "score": 1.0, + "content": "Pose aligned networks for deep attribute modeling. In The IEEE Conference on Computer Vision", + "type": "text", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 298, + 298, + 309 + ], + "spans": [ + { + "bbox": [ + 115, + 298, + 298, + 309 + ], + "score": 1.0, + "content": "and Pattern Recognition (CVPR), June 2014.", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_end_line": true + } + ], + "index": 23.5, + "bbox_fs": [ + 104, + 80, + 507, + 735 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 81, + 506, + 309 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "Valentin Thomas, Jules Pondard, Emmanuel Bengio, Marc Sarfati, Philippe Beaudoin, Marie-Jean", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 93, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 115, + 93, + 505, + 107 + ], + "score": 1.0, + "content": "Meurs, Joelle Pineau, Doina Precup, and Yoshua Bengio. Independently controllable factors.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 117, + 105, + 452, + 117 + ], + "spans": [ + { + "bbox": [ + 117, + 105, + 452, + 117 + ], + "score": 1.0, + "content": "CoRR, abs/1708.01289, 2017. URL http://arxiv.org/abs/1708.01289.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 104, + 121, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 104, + 121, + 505, + 136 + ], + "score": 1.0, + "content": "Sebastian Thrun and Anton Schwartz. Finding structure in reinforcement learning. In NIPS, pp.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 116, + 133, + 228, + 145 + ], + "spans": [ + { + "bbox": [ + 116, + 133, + 228, + 145 + ], + "score": 1.0, + "content": "385–392. MIT Press, 1994.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 151, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 505, + 163 + ], + "score": 1.0, + "content": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 161, + 270, + 173 + ], + "spans": [ + { + "bbox": [ + 115, + 161, + 270, + 173 + ], + "score": 1.0, + "content": "In IROS, pp. 5026–5033. IEEE, 2012.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 179, + 505, + 191 + ], + "spans": [ + { + "bbox": [ + 105, + 179, + 505, + 191 + ], + "score": 1.0, + "content": "M. van Otterlo. A Survey of Reinforcement Learning in Relational Domains. Number 31 in TR-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 189, + 506, + 203 + ], + "spans": [ + { + "bbox": [ + 115, + 189, + 506, + 203 + ], + "score": 1.0, + "content": "CTIT-05, ISSN 1381-3625. Centre for Telematics and Information Technology University of", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 116, + 200, + 176, + 213 + ], + "spans": [ + { + "bbox": [ + 116, + 200, + 176, + 213 + ], + "score": 1.0, + "content": "Twente, 2005.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 218, + 505, + 231 + ], + "spans": [ + { + "bbox": [ + 105, + 218, + 505, + 231 + ], + "score": 1.0, + "content": "Harm van Seijen, Mehdi Fatemi, Joshua Romoff, Romain Laroche, Tavian Barnes, and Jeffrey", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 116, + 230, + 490, + 243 + ], + "spans": [ + { + "bbox": [ + 116, + 230, + 490, + 243 + ], + "score": 1.0, + "content": "Tsang. Hybrid reward architecture for reinforcement learning. CoRR, abs/1706.04208, 2017.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 246, + 506, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 506, + 261 + ], + "score": 1.0, + "content": "Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 258, + 325, + 271 + ], + "spans": [ + { + "bbox": [ + 116, + 258, + 325, + 271 + ], + "score": 1.0, + "content": "learning. In Machine Learning, pp. 229–256, 1992.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 274, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 274, + 505, + 289 + ], + "score": 1.0, + "content": "Ning Zhang, Manohar Paluri, Marc’Aurelio Ranzato, Trevor Darrell, and Lubomir Bourdev. Panda:", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 286, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 115, + 286, + 506, + 299 + ], + "score": 1.0, + "content": "Pose aligned networks for deep attribute modeling. In The IEEE Conference on Computer Vision", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 298, + 298, + 309 + ], + "spans": [ + { + "bbox": [ + 115, + 298, + 298, + 309 + ], + "score": 1.0, + "content": "and Pattern Recognition (CVPR), June 2014.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 8 + }, + { + "type": "title", + "bbox": [ + 108, + 327, + 248, + 340 + ], + "lines": [ + { + "bbox": [ + 106, + 327, + 250, + 342 + ], + "spans": [ + { + "bbox": [ + 106, + 327, + 250, + 342 + ], + "score": 1.0, + "content": "A ADDING EXPLORATION", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 351, + 505, + 409 + ], + "lines": [ + { + "bbox": [ + 106, + 351, + 506, + 365 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 506, + 365 + ], + "score": 1.0, + "content": "We also look into the use of exploration and learn a policy to promote exploration of undiscovered", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 362, + 505, + 378 + ], + "spans": [ + { + "bbox": [ + 106, + 363, + 396, + 377 + ], + "score": 1.0, + "content": "edges in our planning graph. We give a negative reward proportional to", + "type": "text" + }, + { + "bbox": [ + 396, + 362, + 411, + 378 + ], + "score": 0.92, + "content": "\\frac { \\mathbf { \\dot { \\phi } } _ { t } } { \\sqrt { n } }", + "type": "inline_equation" + }, + { + "bbox": [ + 411, + 363, + 439, + 377 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 439, + 365, + 446, + 372 + ], + "score": 0.76, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 363, + 505, + 377 + ], + "score": 1.0, + "content": "is the number", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 375, + 506, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 375, + 321, + 388 + ], + "score": 1.0, + "content": "of times that edge has been encountered before and", + "type": "text" + }, + { + "bbox": [ + 321, + 377, + 327, + 386 + ], + "score": 0.68, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 327, + 375, + 506, + 388 + ], + "score": 1.0, + "content": "the time episode. We compare this with a", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 387, + 505, + 399 + ], + "spans": [ + { + "bbox": [ + 106, + 387, + 398, + 399 + ], + "score": 1.0, + "content": "baseline method of single random start and random action selection over", + "type": "text" + }, + { + "bbox": [ + 398, + 387, + 409, + 397 + ], + "score": 0.82, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 387, + 505, + 399 + ], + "score": 1.0, + "content": "and the method used in", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 397, + 336, + 410 + ], + "spans": [ + { + "bbox": [ + 106, + 397, + 190, + 410 + ], + "score": 1.0, + "content": "the main paper, with", + "type": "text" + }, + { + "bbox": [ + 190, + 398, + 201, + 408 + ], + "score": 0.79, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 397, + 336, + 410 + ], + "score": 1.0, + "content": "random starts and single rollouts.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20 + }, + { + "type": "title", + "bbox": [ + 108, + 422, + 223, + 433 + ], + "lines": [ + { + "bbox": [ + 106, + 421, + 225, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 225, + 435 + ], + "score": 1.0, + "content": "A.1 MAZEBASE RESULTS", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 442, + 505, + 520 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 506, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 506, + 456 + ], + "score": 1.0, + "content": "Our Mazebase environments in Section 4.1 are designed so that all edges can be discovered without", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "score": 1.0, + "content": "much exploration. So to better test the benefit of exploration, we modified the craft environment to", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 464, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 505, + 477 + ], + "score": 1.0, + "content": "make discovering all edges harder. First, we added 4 new “super” products that can be crafted by", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 476, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 476, + 505, + 487 + ], + "score": 1.0, + "content": "combining one normal product with another resource, or three resources. Second, the environment", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 486, + 506, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 506, + 498 + ], + "score": 1.0, + "content": "always starts with only 3 resources and an empty inventory. Therefore, it is much harder to discover", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 498, + 505, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 505, + 510 + ], + "score": 1.0, + "content": "a super product because it requires agent to craft a product out of two resources, and then pick", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 509, + 215, + 520 + ], + "spans": [ + { + "bbox": [ + 106, + 509, + 215, + 520 + ], + "score": 1.0, + "content": "another resource and craft.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 106, + 525, + 506, + 603 + ], + "lines": [ + { + "bbox": [ + 105, + 524, + 506, + 539 + ], + "spans": [ + { + "bbox": [ + 105, + 524, + 506, + 539 + ], + "score": 1.0, + "content": "In this hard crafting environment, a random agent discovered 18.6 edges on average, while an agent", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 537, + 505, + 548 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 505, + 548 + ], + "score": 1.0, + "content": "with the exploration reward discovered all 25 edges of the environment. We used this complete", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 547, + 506, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 506, + 560 + ], + "score": 1.0, + "content": "graph to train our AP model and other baselines. Training on one-step tasks require episodes to start", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 558, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 505, + 571 + ], + "score": 1.0, + "content": "from different nodes of the graph, but the environment always initializes at the same node. A simple", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 569, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 569, + 505, + 581 + ], + "score": 1.0, + "content": "solution was not to reset the environment between episodes if the previous episode was successful.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 579, + 505, + 594 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 505, + 594 + ], + "score": 1.0, + "content": "Thus the next episodes will start from a different node. Table 4 shows the success rates on multi-step", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 592, + 376, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 592, + 376, + 603 + ], + "score": 1.0, + "content": "tasks, where our AP model clearly outperforms the other baselines.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 34 + }, + { + "type": "table", + "bbox": [ + 165, + 612, + 444, + 669 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 165, + 612, + 444, + 669 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 165, + 612, + 444, + 669 + ], + "spans": [ + { + "bbox": [ + 165, + 612, + 444, + 669 + ], + "score": 0.979, + "html": "
MethodTraining dataHard Crafting (multi-step)
Reinforcemulti-step + curriculum51.5%
Reinforceone-step26.0%
APone-step99.8%
", + "type": "table", + "image_path": "e405e424f48befdc453e19a6849c522cde2c703ae1995926a3003bcf8c43bffb.jpg" + } + ] + } + ], + "index": 39, + "virtual_lines": [ + { + "bbox": [ + 165, + 612, + 444, + 631.0 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 165, + 631.0, + 444, + 650.0 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 165, + 650.0, + 444, + 669.0 + ], + "spans": [], + "index": 40 + } + ] + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 105, + 677, + 505, + 700 + ], + "lines": [ + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "score": 1.0, + "content": "Table 4: Task success rate on multi-step task in the hard crafting environment. Our Attribute Planner", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 688, + 295, + 701 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 295, + 701 + ], + "score": 1.0, + "content": "clearly outperforms other baseline approaches.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + }, + { + "type": "title", + "bbox": [ + 108, + 716, + 258, + 728 + ], + "lines": [ + { + "bbox": [ + 106, + 716, + 259, + 729 + ], + "spans": [ + { + "bbox": [ + 106, + 716, + 259, + 729 + ], + "score": 1.0, + "content": "A.2 STACKING BLOCKS RESULTS", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 43 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "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" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 105, + 81, + 506, + 309 + ], + "lines": [], + "index": 8, + "bbox_fs": [ + 104, + 82, + 506, + 309 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 108, + 327, + 248, + 340 + ], + "lines": [ + { + "bbox": [ + 106, + 327, + 250, + 342 + ], + "spans": [ + { + "bbox": [ + 106, + 327, + 250, + 342 + ], + "score": 1.0, + "content": "A ADDING EXPLORATION", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 351, + 505, + 409 + ], + "lines": [ + { + "bbox": [ + 106, + 351, + 506, + 365 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 506, + 365 + ], + "score": 1.0, + "content": "We also look into the use of exploration and learn a policy to promote exploration of undiscovered", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 362, + 505, + 378 + ], + "spans": [ + { + "bbox": [ + 106, + 363, + 396, + 377 + ], + "score": 1.0, + "content": "edges in our planning graph. We give a negative reward proportional to", + "type": "text" + }, + { + "bbox": [ + 396, + 362, + 411, + 378 + ], + "score": 0.92, + "content": "\\frac { \\mathbf { \\dot { \\phi } } _ { t } } { \\sqrt { n } }", + "type": "inline_equation" + }, + { + "bbox": [ + 411, + 363, + 439, + 377 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 439, + 365, + 446, + 372 + ], + "score": 0.76, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 363, + 505, + 377 + ], + "score": 1.0, + "content": "is the number", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 375, + 506, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 375, + 321, + 388 + ], + "score": 1.0, + "content": "of times that edge has been encountered before and", + "type": "text" + }, + { + "bbox": [ + 321, + 377, + 327, + 386 + ], + "score": 0.68, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 327, + 375, + 506, + 388 + ], + "score": 1.0, + "content": "the time episode. We compare this with a", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 387, + 505, + 399 + ], + "spans": [ + { + "bbox": [ + 106, + 387, + 398, + 399 + ], + "score": 1.0, + "content": "baseline method of single random start and random action selection over", + "type": "text" + }, + { + "bbox": [ + 398, + 387, + 409, + 397 + ], + "score": 0.82, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 387, + 505, + 399 + ], + "score": 1.0, + "content": "and the method used in", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 397, + 336, + 410 + ], + "spans": [ + { + "bbox": [ + 106, + 397, + 190, + 410 + ], + "score": 1.0, + "content": "the main paper, with", + "type": "text" + }, + { + "bbox": [ + 190, + 398, + 201, + 408 + ], + "score": 0.79, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 397, + 336, + 410 + ], + "score": 1.0, + "content": "random starts and single rollouts.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20, + "bbox_fs": [ + 106, + 351, + 506, + 410 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 422, + 223, + 433 + ], + "lines": [ + { + "bbox": [ + 106, + 421, + 225, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 225, + 435 + ], + "score": 1.0, + "content": "A.1 MAZEBASE RESULTS", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 442, + 505, + 520 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 506, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 506, + 456 + ], + "score": 1.0, + "content": "Our Mazebase environments in Section 4.1 are designed so that all edges can be discovered without", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "score": 1.0, + "content": "much exploration. So to better test the benefit of exploration, we modified the craft environment to", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 464, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 505, + 477 + ], + "score": 1.0, + "content": "make discovering all edges harder. First, we added 4 new “super” products that can be crafted by", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 476, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 476, + 505, + 487 + ], + "score": 1.0, + "content": "combining one normal product with another resource, or three resources. Second, the environment", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 486, + 506, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 506, + 498 + ], + "score": 1.0, + "content": "always starts with only 3 resources and an empty inventory. Therefore, it is much harder to discover", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 498, + 505, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 505, + 510 + ], + "score": 1.0, + "content": "a super product because it requires agent to craft a product out of two resources, and then pick", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 509, + 215, + 520 + ], + "spans": [ + { + "bbox": [ + 106, + 509, + 215, + 520 + ], + "score": 1.0, + "content": "another resource and craft.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 442, + 506, + 520 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 525, + 506, + 603 + ], + "lines": [ + { + "bbox": [ + 105, + 524, + 506, + 539 + ], + "spans": [ + { + "bbox": [ + 105, + 524, + 506, + 539 + ], + "score": 1.0, + "content": "In this hard crafting environment, a random agent discovered 18.6 edges on average, while an agent", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 537, + 505, + 548 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 505, + 548 + ], + "score": 1.0, + "content": "with the exploration reward discovered all 25 edges of the environment. We used this complete", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 547, + 506, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 506, + 560 + ], + "score": 1.0, + "content": "graph to train our AP model and other baselines. Training on one-step tasks require episodes to start", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 558, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 505, + 571 + ], + "score": 1.0, + "content": "from different nodes of the graph, but the environment always initializes at the same node. A simple", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 569, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 569, + 505, + 581 + ], + "score": 1.0, + "content": "solution was not to reset the environment between episodes if the previous episode was successful.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 579, + 505, + 594 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 505, + 594 + ], + "score": 1.0, + "content": "Thus the next episodes will start from a different node. Table 4 shows the success rates on multi-step", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 592, + 376, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 592, + 376, + 603 + ], + "score": 1.0, + "content": "tasks, where our AP model clearly outperforms the other baselines.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 34, + "bbox_fs": [ + 105, + 524, + 506, + 603 + ] + }, + { + "type": "table", + "bbox": [ + 165, + 612, + 444, + 669 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 165, + 612, + 444, + 669 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 165, + 612, + 444, + 669 + ], + "spans": [ + { + "bbox": [ + 165, + 612, + 444, + 669 + ], + "score": 0.979, + "html": "
MethodTraining dataHard Crafting (multi-step)
Reinforcemulti-step + curriculum51.5%
Reinforceone-step26.0%
APone-step99.8%
", + "type": "table", + "image_path": "e405e424f48befdc453e19a6849c522cde2c703ae1995926a3003bcf8c43bffb.jpg" + } + ] + } + ], + "index": 39, + "virtual_lines": [ + { + "bbox": [ + 165, + 612, + 444, + 631.0 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 165, + 631.0, + 444, + 650.0 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 165, + 650.0, + 444, + 669.0 + ], + "spans": [], + "index": 40 + } + ] + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 105, + 677, + 505, + 700 + ], + "lines": [ + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "score": 1.0, + "content": "Table 4: Task success rate on multi-step task in the hard crafting environment. Our Attribute Planner", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 688, + 295, + 701 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 295, + 701 + ], + "score": 1.0, + "content": "clearly outperforms other baseline approaches.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5, + "bbox_fs": [ + 105, + 676, + 505, + 701 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 716, + 258, + 728 + ], + "lines": [ + { + "bbox": [ + 106, + 716, + 259, + 729 + ], + "spans": [ + { + "bbox": [ + 106, + 716, + 259, + 729 + ], + "score": 1.0, + "content": "A.2 STACKING BLOCKS RESULTS", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 43 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 149, + 348, + 462, + 416 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 149, + 348, + 462, + 416 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 149, + 348, + 462, + 416 + ], + "spans": [ + { + "bbox": [ + 149, + 348, + 462, + 416 + ], + "score": 0.974, + "html": "
# of Training ExamplesPolicyRandomMain Method
edges accuracyedgesaccuracyedgesaccuracy
100,00044k49.4%49k49.7%38k47.0%
1,000,000120k67.5%130k69.8%114k66.7%
10,000,000139k80.6%138k83.1%218k70.7%
", + "type": "table", + "image_path": "9010c347820f00c2fd1adf405e10fd26af0322e88edf5f43f02965e1e900eba2.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 149, + 348, + 462, + 370.6666666666667 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 149, + 370.6666666666667, + 462, + 393.33333333333337 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 149, + 393.33333333333337, + 462, + 416.00000000000006 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 106, + 429, + 505, + 463 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 428, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 505, + 442 + ], + "score": 1.0, + "content": "Table 5: Effect of the number of (one-step) training examples on one-step and multi-step perfor-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 439, + 504, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 492, + 451 + ], + "score": 1.0, + "content": "mance, for an inverse model and the Attribute Planner model. The inverse models are trained on", + "type": "text" + }, + { + "bbox": [ + 492, + 440, + 504, + 450 + ], + "score": 0.68, + "content": "2 \\mathbf { x }", + "type": "inline_equation" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 451, + 434, + 463 + ], + "spans": [ + { + "bbox": [ + 106, + 451, + 345, + 463 + ], + "score": 1.0, + "content": "the samples, including the samples generated from learning", + "type": "text" + }, + { + "bbox": [ + 346, + 452, + 357, + 462 + ], + "score": 0.85, + "content": "c _ { \\pi }", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 451, + 434, + 463 + ], + "score": 1.0, + "content": "in our AP method.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + } + ], + "page_idx": 12, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 27, + 308, + 38 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "13", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 149, + 348, + 462, + 416 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 149, + 348, + 462, + 416 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 149, + 348, + 462, + 416 + ], + "spans": [ + { + "bbox": [ + 149, + 348, + 462, + 416 + ], + "score": 0.974, + "html": "
# of Training ExamplesPolicyRandomMain Method
edges accuracyedgesaccuracyedgesaccuracy
100,00044k49.4%49k49.7%38k47.0%
1,000,000120k67.5%130k69.8%114k66.7%
10,000,000139k80.6%138k83.1%218k70.7%
", + "type": "table", + "image_path": "9010c347820f00c2fd1adf405e10fd26af0322e88edf5f43f02965e1e900eba2.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 149, + 348, + 462, + 370.6666666666667 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 149, + 370.6666666666667, + 462, + 393.33333333333337 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 149, + 393.33333333333337, + 462, + 416.00000000000006 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 106, + 429, + 505, + 463 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 428, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 505, + 442 + ], + "score": 1.0, + "content": "Table 5: Effect of the number of (one-step) training examples on one-step and multi-step perfor-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 439, + 504, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 492, + 451 + ], + "score": 1.0, + "content": "mance, for an inverse model and the Attribute Planner model. The inverse models are trained on", + "type": "text" + }, + { + "bbox": [ + 492, + 440, + 504, + 450 + ], + "score": 0.68, + "content": "2 \\mathbf { x }", + "type": "inline_equation" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 451, + 434, + 463 + ], + "spans": [ + { + "bbox": [ + 106, + 451, + 345, + 463 + ], + "score": 1.0, + "content": "the samples, including the samples generated from learning", + "type": "text" + }, + { + "bbox": [ + 346, + 452, + 357, + 462 + ], + "score": 0.85, + "content": "c _ { \\pi }", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 451, + 434, + 463 + ], + "score": 1.0, + "content": "in our AP method.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file