diff --git "a/parse/train/SkT5Yg-RZ/SkT5Yg-RZ_middle.json" "b/parse/train/SkT5Yg-RZ/SkT5Yg-RZ_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/SkT5Yg-RZ/SkT5Yg-RZ_middle.json" @@ -0,0 +1,40913 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 106, + 79, + 421, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 79, + 417, + 97 + ], + "spans": [ + { + "bbox": [ + 106, + 79, + 417, + 97 + ], + "score": 1.0, + "content": "INTRINSIC MOTIVATION AND AUTOMATIC", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 98, + 423, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 98, + 423, + 117 + ], + "score": 1.0, + "content": "CURRICULA VIA ASYMMETRIC SELF-PLAY", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 112, + 135, + 223, + 180 + ], + "lines": [ + { + "bbox": [ + 113, + 136, + 211, + 146 + ], + "spans": [ + { + "bbox": [ + 113, + 136, + 211, + 146 + ], + "score": 1.0, + "content": "Sainbayar Sukhbaatar", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 112, + 146, + 224, + 158 + ], + "spans": [ + { + "bbox": [ + 112, + 146, + 224, + 158 + ], + "score": 1.0, + "content": "Dept. of Computer Science", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 111, + 155, + 200, + 170 + ], + "spans": [ + { + "bbox": [ + 111, + 155, + 200, + 170 + ], + "score": 1.0, + "content": "New York University", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 112, + 169, + 222, + 180 + ], + "spans": [ + { + "bbox": [ + 112, + 169, + 222, + 180 + ], + "score": 1.0, + "content": "sainbar@cs.nyu.edu", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 254, + 135, + 346, + 179 + ], + "lines": [ + { + "bbox": [ + 253, + 135, + 307, + 147 + ], + "spans": [ + { + "bbox": [ + 253, + 135, + 307, + 147 + ], + "score": 1.0, + "content": "Zeming Lin", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 253, + 145, + 347, + 158 + ], + "spans": [ + { + "bbox": [ + 253, + 145, + 347, + 158 + ], + "score": 1.0, + "content": "Facebook AI Research", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 253, + 156, + 298, + 168 + ], + "spans": [ + { + "bbox": [ + 253, + 156, + 298, + 168 + ], + "score": 1.0, + "content": "New York", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 253, + 168, + 322, + 180 + ], + "spans": [ + { + "bbox": [ + 253, + 168, + 322, + 180 + ], + "score": 1.0, + "content": "zlin@fb.com", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 376, + 136, + 498, + 180 + ], + "lines": [ + { + "bbox": [ + 376, + 135, + 441, + 147 + ], + "spans": [ + { + "bbox": [ + 376, + 135, + 441, + 147 + ], + "score": 1.0, + "content": "Ilya Kostrikov", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 376, + 145, + 488, + 159 + ], + "spans": [ + { + "bbox": [ + 376, + 145, + 488, + 159 + ], + "score": 1.0, + "content": "Dept. of Computer Science", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 376, + 155, + 464, + 170 + ], + "spans": [ + { + "bbox": [ + 376, + 155, + 464, + 170 + ], + "score": 1.0, + "content": "New York University", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 376, + 168, + 499, + 181 + ], + "spans": [ + { + "bbox": [ + 376, + 168, + 499, + 181 + ], + "score": 1.0, + "content": "kostrikov@cs.nyu.edu", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 8.5 + }, + { + "type": "title", + "bbox": [ + 114, + 196, + 316, + 207 + ], + "lines": [ + { + "bbox": [ + 112, + 196, + 317, + 210 + ], + "spans": [ + { + "bbox": [ + 112, + 196, + 317, + 210 + ], + "score": 1.0, + "content": "Gabriel Synnaeve, Arthur Szlam & Rob Fergus", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 113, + 209, + 286, + 241 + ], + "lines": [ + { + "bbox": [ + 111, + 207, + 205, + 219 + ], + "spans": [ + { + "bbox": [ + 111, + 207, + 205, + 219 + ], + "score": 1.0, + "content": "Facebook AI Research", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 112, + 217, + 156, + 229 + ], + "spans": [ + { + "bbox": [ + 112, + 217, + 156, + 229 + ], + "score": 1.0, + "content": "New York", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 112, + 230, + 286, + 242 + ], + "spans": [ + { + "bbox": [ + 112, + 230, + 286, + 242 + ], + "score": 1.0, + "content": "{gab,aszlam,robfergus}@fb.com", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16 + }, + { + "type": "title", + "bbox": [ + 278, + 270, + 333, + 281 + ], + "lines": [ + { + "bbox": [ + 276, + 268, + 336, + 284 + ], + "spans": [ + { + "bbox": [ + 276, + 268, + 336, + 284 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 143, + 294, + 468, + 415 + ], + "lines": [ + { + "bbox": [ + 142, + 295, + 470, + 307 + ], + "spans": [ + { + "bbox": [ + 142, + 295, + 470, + 307 + ], + "score": 1.0, + "content": "We describe a simple scheme that allows an agent to learn about its environment", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 306, + 470, + 318 + ], + "spans": [ + { + "bbox": [ + 141, + 306, + 470, + 318 + ], + "score": 1.0, + "content": "in an unsupervised manner. Our scheme pits two versions of the same agent, Al-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 141, + 317, + 469, + 329 + ], + "spans": [ + { + "bbox": [ + 141, + 317, + 469, + 329 + ], + "score": 1.0, + "content": "ice and Bob, against one another. Alice proposes a task for Bob to complete; and", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 328, + 469, + 339 + ], + "spans": [ + { + "bbox": [ + 141, + 328, + 469, + 339 + ], + "score": 1.0, + "content": "then Bob attempts to complete the task. In this work we will focus on two kinds", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 142, + 339, + 470, + 350 + ], + "spans": [ + { + "bbox": [ + 142, + 339, + 470, + 350 + ], + "score": 1.0, + "content": "of environments: (nearly) reversible environments and environments that can be", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 141, + 349, + 470, + 362 + ], + "spans": [ + { + "bbox": [ + 141, + 349, + 470, + 362 + ], + "score": 1.0, + "content": "reset. Alice will “propose” the task by doing a sequence of actions and then Bob", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 141, + 361, + 470, + 373 + ], + "spans": [ + { + "bbox": [ + 141, + 361, + 470, + 373 + ], + "score": 1.0, + "content": "must undo or repeat them, respectively. Via an appropriate reward structure, Alice", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 141, + 371, + 470, + 385 + ], + "spans": [ + { + "bbox": [ + 141, + 371, + 470, + 385 + ], + "score": 1.0, + "content": "and Bob automatically generate a curriculum of exploration, enabling unsuper-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 142, + 383, + 469, + 394 + ], + "spans": [ + { + "bbox": [ + 142, + 383, + 469, + 394 + ], + "score": 1.0, + "content": "vised training of the agent. When Bob is deployed on an RL task within the en-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 142, + 394, + 469, + 406 + ], + "spans": [ + { + "bbox": [ + 142, + 394, + 469, + 406 + ], + "score": 1.0, + "content": "vironment, this unsupervised training reduces the number of supervised episodes", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 141, + 404, + 402, + 417 + ], + "spans": [ + { + "bbox": [ + 141, + 404, + 402, + 417 + ], + "score": 1.0, + "content": "needed to learn, and in some cases converges to a higher reward.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 24 + }, + { + "type": "title", + "bbox": [ + 108, + 437, + 206, + 450 + ], + "lines": [ + { + "bbox": [ + 105, + 436, + 208, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 436, + 208, + 453 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 107, + 462, + 504, + 529 + ], + "lines": [ + { + "bbox": [ + 105, + 461, + 506, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 506, + 477 + ], + "score": 1.0, + "content": "Model-free approaches to reinforcement learning are sample inefficient, typically requiring a huge", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 474, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 505, + 486 + ], + "score": 1.0, + "content": "number of episodes to learn a satisfactory policy. The lack of an explicit environment model means", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 485, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 106, + 485, + 505, + 497 + ], + "score": 1.0, + "content": "the agent must learn the rules of the environment from scratch at the same time as it tries to un-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 496, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 505, + 507 + ], + "score": 1.0, + "content": "derstand which trajectories lead to rewards. In environments where reward is sparse, only a small", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 506, + 506, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 506, + 520 + ], + "score": 1.0, + "content": "fraction of the agents’ experience is directly used to update the policy, contributing to the ineffi-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 516, + 138, + 531 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 138, + 531 + ], + "score": 1.0, + "content": "ciency.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 33.5 + }, + { + "type": "text", + "bbox": [ + 107, + 534, + 505, + 578 + ], + "lines": [ + { + "bbox": [ + 105, + 534, + 505, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 505, + 547 + ], + "score": 1.0, + "content": "In this paper we introduce a novel form of unsupervised training for an agent that enables exploration", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 546, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 505, + 558 + ], + "score": 1.0, + "content": "and learning about the environment without any external reward that incentivizes the agents to learn", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 556, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 505, + 569 + ], + "score": 1.0, + "content": "how to transition between states as efficiently as possible. We demonstrate that this unsupervised", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 567, + 410, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 410, + 580 + ], + "score": 1.0, + "content": "training allows the agent to learn new tasks within the environment quickly.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38.5 + }, + { + "type": "title", + "bbox": [ + 107, + 594, + 183, + 607 + ], + "lines": [ + { + "bbox": [ + 104, + 592, + 185, + 610 + ], + "spans": [ + { + "bbox": [ + 104, + 592, + 185, + 610 + ], + "score": 1.0, + "content": "2 APPROACH", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 107, + 615, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 615, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 630 + ], + "score": 1.0, + "content": "We consider environments with a single physical agent (or multiple physical units controlled by", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "a single agent), but we allow it to have two separate “minds”: Alice and Bob, each with its own", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 638, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 505, + 651 + ], + "score": 1.0, + "content": "objective and parameters. During self-play episodes, Alice’s job is to propose a task for Bob to", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "complete, and Bob’s job is to complete the task. When presented with a target task episode, Bob is", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "then used to perform it (Alice plays no role). The key idea is that the Bob’s play with Alice should", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "score": 1.0, + "content": "help him understand how the environment works and enabling him to learn the target task more", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 681, + 142, + 696 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 142, + 696 + ], + "score": 1.0, + "content": "quickly.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 45 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "Our approach is restricted to two classes of environment: (i) those that are (nearly) reversible, or", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "(ii) ones that can be reset to their initial state (at least once). These restrictions allow us to sidestep", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 720, + 506, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 732 + ], + "score": 1.0, + "content": "complications around how to communicate the task and determine its difficulty (see Appendix F.2", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 50 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 303, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 308, + 761 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 308, + 761 + ], + "score": 1.0, + "content": "1", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 106, + 79, + 421, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 79, + 417, + 97 + ], + "spans": [ + { + "bbox": [ + 106, + 79, + 417, + 97 + ], + "score": 1.0, + "content": "INTRINSIC MOTIVATION AND AUTOMATIC", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 98, + 423, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 98, + 423, + 117 + ], + "score": 1.0, + "content": "CURRICULA VIA ASYMMETRIC SELF-PLAY", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 112, + 135, + 223, + 180 + ], + "lines": [ + { + "bbox": [ + 113, + 136, + 211, + 146 + ], + "spans": [ + { + "bbox": [ + 113, + 136, + 211, + 146 + ], + "score": 1.0, + "content": "Sainbayar Sukhbaatar", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 112, + 146, + 224, + 158 + ], + "spans": [ + { + "bbox": [ + 112, + 146, + 224, + 158 + ], + "score": 1.0, + "content": "Dept. of Computer Science", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 111, + 155, + 200, + 170 + ], + "spans": [ + { + "bbox": [ + 111, + 155, + 200, + 170 + ], + "score": 1.0, + "content": "New York University", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 112, + 169, + 222, + 180 + ], + "spans": [ + { + "bbox": [ + 112, + 169, + 222, + 180 + ], + "score": 1.0, + "content": "sainbar@cs.nyu.edu", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 6.5, + "bbox_fs": [ + 111, + 136, + 224, + 180 + ] + }, + { + "type": "list", + "bbox": [ + 254, + 135, + 346, + 179 + ], + "lines": [ + { + "bbox": [ + 253, + 135, + 307, + 147 + ], + "spans": [ + { + "bbox": [ + 253, + 135, + 307, + 147 + ], + "score": 1.0, + "content": "Zeming Lin", + "type": "text" + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 253, + 145, + 347, + 158 + ], + "spans": [ + { + "bbox": [ + 253, + 145, + 347, + 158 + ], + "score": 1.0, + "content": "Facebook AI Research", + "type": "text" + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 253, + 156, + 298, + 168 + ], + "spans": [ + { + "bbox": [ + 253, + 156, + 298, + 168 + ], + "score": 1.0, + "content": "New York", + "type": "text" + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 253, + 168, + 322, + 180 + ], + "spans": [ + { + "bbox": [ + 253, + 168, + 322, + 180 + ], + "score": 1.0, + "content": "zlin@fb.com", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + } + ], + "index": 7.5, + "bbox_fs": [ + 253, + 135, + 347, + 180 + ] + }, + { + "type": "text", + "bbox": [ + 376, + 136, + 498, + 180 + ], + "lines": [ + { + "bbox": [ + 376, + 135, + 441, + 147 + ], + "spans": [ + { + "bbox": [ + 376, + 135, + 441, + 147 + ], + "score": 1.0, + "content": "Ilya Kostrikov", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 376, + 145, + 488, + 159 + ], + "spans": [ + { + "bbox": [ + 376, + 145, + 488, + 159 + ], + "score": 1.0, + "content": "Dept. of Computer Science", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 376, + 155, + 464, + 170 + ], + "spans": [ + { + "bbox": [ + 376, + 155, + 464, + 170 + ], + "score": 1.0, + "content": "New York University", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 376, + 168, + 499, + 181 + ], + "spans": [ + { + "bbox": [ + 376, + 168, + 499, + 181 + ], + "score": 1.0, + "content": "kostrikov@cs.nyu.edu", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 8.5, + "bbox_fs": [ + 376, + 135, + 499, + 181 + ] + }, + { + "type": "title", + "bbox": [ + 114, + 196, + 316, + 207 + ], + "lines": [ + { + "bbox": [ + 112, + 196, + 317, + 210 + ], + "spans": [ + { + "bbox": [ + 112, + 196, + 317, + 210 + ], + "score": 1.0, + "content": "Gabriel Synnaeve, Arthur Szlam & Rob Fergus", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "list", + "bbox": [ + 113, + 209, + 286, + 241 + ], + "lines": [ + { + "bbox": [ + 111, + 207, + 205, + 219 + ], + "spans": [ + { + "bbox": [ + 111, + 207, + 205, + 219 + ], + "score": 1.0, + "content": "Facebook AI Research", + "type": "text" + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 112, + 217, + 156, + 229 + ], + "spans": [ + { + "bbox": [ + 112, + 217, + 156, + 229 + ], + "score": 1.0, + "content": "New York", + "type": "text" + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 112, + 230, + 286, + 242 + ], + "spans": [ + { + "bbox": [ + 112, + 230, + 286, + 242 + ], + "score": 1.0, + "content": "{gab,aszlam,robfergus}@fb.com", + "type": "text" + } + ], + "index": 17, + "is_list_start_line": true + } + ], + "index": 16, + "bbox_fs": [ + 111, + 207, + 286, + 242 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 270, + 333, + 281 + ], + "lines": [ + { + "bbox": [ + 276, + 268, + 336, + 284 + ], + "spans": [ + { + "bbox": [ + 276, + 268, + 336, + 284 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 143, + 294, + 468, + 415 + ], + "lines": [ + { + "bbox": [ + 142, + 295, + 470, + 307 + ], + "spans": [ + { + "bbox": [ + 142, + 295, + 470, + 307 + ], + "score": 1.0, + "content": "We describe a simple scheme that allows an agent to learn about its environment", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 306, + 470, + 318 + ], + "spans": [ + { + "bbox": [ + 141, + 306, + 470, + 318 + ], + "score": 1.0, + "content": "in an unsupervised manner. Our scheme pits two versions of the same agent, Al-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 141, + 317, + 469, + 329 + ], + "spans": [ + { + "bbox": [ + 141, + 317, + 469, + 329 + ], + "score": 1.0, + "content": "ice and Bob, against one another. Alice proposes a task for Bob to complete; and", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 328, + 469, + 339 + ], + "spans": [ + { + "bbox": [ + 141, + 328, + 469, + 339 + ], + "score": 1.0, + "content": "then Bob attempts to complete the task. In this work we will focus on two kinds", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 142, + 339, + 470, + 350 + ], + "spans": [ + { + "bbox": [ + 142, + 339, + 470, + 350 + ], + "score": 1.0, + "content": "of environments: (nearly) reversible environments and environments that can be", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 141, + 349, + 470, + 362 + ], + "spans": [ + { + "bbox": [ + 141, + 349, + 470, + 362 + ], + "score": 1.0, + "content": "reset. Alice will “propose” the task by doing a sequence of actions and then Bob", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 141, + 361, + 470, + 373 + ], + "spans": [ + { + "bbox": [ + 141, + 361, + 470, + 373 + ], + "score": 1.0, + "content": "must undo or repeat them, respectively. Via an appropriate reward structure, Alice", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 141, + 371, + 470, + 385 + ], + "spans": [ + { + "bbox": [ + 141, + 371, + 470, + 385 + ], + "score": 1.0, + "content": "and Bob automatically generate a curriculum of exploration, enabling unsuper-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 142, + 383, + 469, + 394 + ], + "spans": [ + { + "bbox": [ + 142, + 383, + 469, + 394 + ], + "score": 1.0, + "content": "vised training of the agent. When Bob is deployed on an RL task within the en-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 142, + 394, + 469, + 406 + ], + "spans": [ + { + "bbox": [ + 142, + 394, + 469, + 406 + ], + "score": 1.0, + "content": "vironment, this unsupervised training reduces the number of supervised episodes", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 141, + 404, + 402, + 417 + ], + "spans": [ + { + "bbox": [ + 141, + 404, + 402, + 417 + ], + "score": 1.0, + "content": "needed to learn, and in some cases converges to a higher reward.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 24, + "bbox_fs": [ + 141, + 295, + 470, + 417 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 437, + 206, + 450 + ], + "lines": [ + { + "bbox": [ + 105, + 436, + 208, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 436, + 208, + 453 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 107, + 462, + 504, + 529 + ], + "lines": [ + { + "bbox": [ + 105, + 461, + 506, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 506, + 477 + ], + "score": 1.0, + "content": "Model-free approaches to reinforcement learning are sample inefficient, typically requiring a huge", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 474, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 505, + 486 + ], + "score": 1.0, + "content": "number of episodes to learn a satisfactory policy. The lack of an explicit environment model means", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 485, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 106, + 485, + 505, + 497 + ], + "score": 1.0, + "content": "the agent must learn the rules of the environment from scratch at the same time as it tries to un-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 496, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 505, + 507 + ], + "score": 1.0, + "content": "derstand which trajectories lead to rewards. In environments where reward is sparse, only a small", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 506, + 506, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 506, + 520 + ], + "score": 1.0, + "content": "fraction of the agents’ experience is directly used to update the policy, contributing to the ineffi-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 516, + 138, + 531 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 138, + 531 + ], + "score": 1.0, + "content": "ciency.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 461, + 506, + 531 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 534, + 505, + 578 + ], + "lines": [ + { + "bbox": [ + 105, + 534, + 505, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 505, + 547 + ], + "score": 1.0, + "content": "In this paper we introduce a novel form of unsupervised training for an agent that enables exploration", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 546, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 505, + 558 + ], + "score": 1.0, + "content": "and learning about the environment without any external reward that incentivizes the agents to learn", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 556, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 505, + 569 + ], + "score": 1.0, + "content": "how to transition between states as efficiently as possible. We demonstrate that this unsupervised", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 567, + 410, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 410, + 580 + ], + "score": 1.0, + "content": "training allows the agent to learn new tasks within the environment quickly.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38.5, + "bbox_fs": [ + 105, + 534, + 505, + 580 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 594, + 183, + 607 + ], + "lines": [ + { + "bbox": [ + 104, + 592, + 185, + 610 + ], + "spans": [ + { + "bbox": [ + 104, + 592, + 185, + 610 + ], + "score": 1.0, + "content": "2 APPROACH", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 107, + 615, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 615, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 630 + ], + "score": 1.0, + "content": "We consider environments with a single physical agent (or multiple physical units controlled by", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "a single agent), but we allow it to have two separate “minds”: Alice and Bob, each with its own", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 638, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 505, + 651 + ], + "score": 1.0, + "content": "objective and parameters. During self-play episodes, Alice’s job is to propose a task for Bob to", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "complete, and Bob’s job is to complete the task. When presented with a target task episode, Bob is", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "then used to perform it (Alice plays no role). The key idea is that the Bob’s play with Alice should", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "score": 1.0, + "content": "help him understand how the environment works and enabling him to learn the target task more", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 681, + 142, + 696 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 142, + 696 + ], + "score": 1.0, + "content": "quickly.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 45, + "bbox_fs": [ + 105, + 615, + 505, + 696 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "Our approach is restricted to two classes of environment: (i) those that are (nearly) reversible, or", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "(ii) ones that can be reset to their initial state (at least once). These restrictions allow us to sidestep", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 720, + 506, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 732 + ], + "score": 1.0, + "content": "complications around how to communicate the task and determine its difficulty (see Appendix F.2", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 303, + 506, + 317 + ], + "spans": [ + { + "bbox": [ + 105, + 303, + 430, + 317 + ], + "score": 1.0, + "content": "for further discussion). In these two scenarios, Alice starts at some initial state", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 430, + 306, + 440, + 316 + ], + "score": 0.86, + "content": "s _ { 0 }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 441, + 303, + 506, + 317 + ], + "score": 1.0, + "content": "and proposes a", + "type": "text", + "cross_page": true + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 316, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 316, + 450, + 327 + ], + "score": 1.0, + "content": "task by doing it, i.e. executing a sequence of actions that takes the agent to a state", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 451, + 317, + 460, + 326 + ], + "score": 0.84, + "content": "s _ { t }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 460, + 316, + 505, + 327 + ], + "score": 1.0, + "content": ". She then", + "type": "text", + "cross_page": true + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 326, + 506, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 506, + 339 + ], + "score": 1.0, + "content": "outputs a STOP action, which hands control over to Bob. In reversible environments, Bob’s goal is", + "type": "text", + "cross_page": true + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 337, + 505, + 349 + ], + "spans": [ + { + "bbox": [ + 106, + 337, + 232, + 349 + ], + "score": 1.0, + "content": "to return the agent back to state", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 232, + 338, + 243, + 348 + ], + "score": 0.85, + "content": "s _ { 0 }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 243, + 337, + 505, + 349 + ], + "score": 1.0, + "content": "(or within some margin of it, if the state is continuous), to receive", + "type": "text", + "cross_page": true + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 349, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 106, + 349, + 506, + 361 + ], + "score": 1.0, + "content": "reward. In partially observable environments, the objective is relaxed to Bob finding a state that", + "type": "text", + "cross_page": true + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 360, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 106, + 360, + 505, + 371 + ], + "score": 1.0, + "content": "returns the same observation as Alice’s initial state. In environments where resets are permissible,", + "type": "text", + "cross_page": true + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 369, + 504, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 369, + 399, + 383 + ], + "score": 1.0, + "content": "Alice’s STOP action also reinitializes the environment, thus Bob starts at", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 399, + 371, + 410, + 381 + ], + "score": 0.85, + "content": "s _ { 0 }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 410, + 369, + 494, + 383 + ], + "score": 1.0, + "content": "and now must reach", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 494, + 371, + 504, + 381 + ], + "score": 0.83, + "content": "s _ { t }", + "type": "inline_equation", + "cross_page": true + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 381, + 505, + 393 + ], + "spans": [ + { + "bbox": [ + 106, + 381, + 505, + 393 + ], + "score": 1.0, + "content": "to be rewarded, thus repeating Alice’s task instead of reversing it. See Fig. 1 for an example, and", + "type": "text", + "cross_page": true + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 392, + 241, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 241, + 404 + ], + "score": 1.0, + "content": "also Algorithm 1 in Appendix A.", + "type": "text", + "cross_page": true + } + ], + "index": 27 + } + ], + "index": 50, + "bbox_fs": [ + 105, + 698, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 372, + 79, + 479, + 175 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 372, + 79, + 479, + 175 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 372, + 79, + 479, + 175 + ], + "spans": [ + { + "bbox": [ + 372, + 79, + 479, + 175 + ], + "score": 0.839, + "type": "image", + "image_path": "7a0fb69b8512612d2b8fa5d73a06dd1b5ae9373c04f571492ab24b6a8c9031ad.jpg" + } + ] + } + ], + "index": 7.5, + "virtual_lines": [ + { + "bbox": [ + 372, + 79, + 479, + 127.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 372, + 127.0, + 479, + 175.0 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 387, + 177, + 464, + 184 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 387, + 175, + 465, + 185 + ], + "spans": [ + { + "bbox": [ + 387, + 175, + 465, + 185 + ], + "score": 1.0, + "content": "Bob\tapplied\tto\ttarget\ttask", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + } + ], + "index": 8.75 + }, + { + "type": "image", + "bbox": [ + 129, + 80, + 356, + 183 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 129, + 80, + 356, + 183 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 129, + 80, + 356, + 183 + ], + "spans": [ + { + "bbox": [ + 129, + 80, + 356, + 183 + ], + "score": 0.317, + "type": "image", + "image_path": "77c7cd4ceefc87391c2fd192d27a67f27251053c83d29d18dc2e3330d52f342f.jpg" + } + ] + } + ], + "index": 3.5, + "virtual_lines": [ + { + "bbox": [ + 129, + 80, + 356, + 92.875 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 129, + 92.875, + 356, + 105.75 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 129, + 105.75, + 356, + 118.625 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 129, + 118.625, + 356, + 131.5 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 129, + 131.5, + 356, + 144.375 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 129, + 144.375, + 356, + 157.25 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 129, + 157.25, + 356, + 170.125 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 129, + 170.125, + 356, + 183.0 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 185, + 505, + 273 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 183, + 506, + 198 + ], + "spans": [ + { + "bbox": [ + 105, + 183, + 506, + 198 + ], + "score": 1.0, + "content": "Figure 1: Illustration of the self-play concept in a gridworld setting. Training consists of two types", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 194, + 506, + 208 + ], + "spans": [ + { + "bbox": [ + 105, + 194, + 506, + 208 + ], + "score": 1.0, + "content": "of episode: self-play and target task. In the former, Alice and Bob take turns moving the agent", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 205, + 505, + 219 + ], + "spans": [ + { + "bbox": [ + 106, + 205, + 505, + 219 + ], + "score": 1.0, + "content": "within the environment. Alice sets tasks by altering the state via interaction with its objects (key,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 217, + 505, + 229 + ], + "spans": [ + { + "bbox": [ + 106, + 217, + 505, + 229 + ], + "score": 1.0, + "content": "door, light) and then hands control over to Bob. He must return the environment to its original state", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 227, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 105, + 227, + 505, + 241 + ], + "score": 1.0, + "content": "to receive an internal reward. This task is just one of many devised by Alice, who automatically", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 238, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 505, + 252 + ], + "score": 1.0, + "content": "builds a curriculum of increasingly challenging tasks. In the target task, Bob’s policy is used to", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 251, + 505, + 262 + ], + "spans": [ + { + "bbox": [ + 106, + 251, + 505, + 262 + ], + "score": 1.0, + "content": "control the agent, with him receiving an external reward if he visits the flag. He is able to learn to", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 260, + 415, + 275 + ], + "spans": [ + { + "bbox": [ + 105, + 260, + 415, + 275 + ], + "score": 1.0, + "content": "do this quickly as he is already familiar with the environment from self-play.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14.5 + } + ], + "index": 9.0 + }, + { + "type": "text", + "bbox": [ + 106, + 303, + 505, + 403 + ], + "lines": [ + { + "bbox": [ + 105, + 303, + 506, + 317 + ], + "spans": [ + { + "bbox": [ + 105, + 303, + 430, + 317 + ], + "score": 1.0, + "content": "for further discussion). In these two scenarios, Alice starts at some initial state", + "type": "text" + }, + { + "bbox": [ + 430, + 306, + 440, + 316 + ], + "score": 0.86, + "content": "s _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 441, + 303, + 506, + 317 + ], + "score": 1.0, + "content": "and proposes a", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 316, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 316, + 450, + 327 + ], + "score": 1.0, + "content": "task by doing it, i.e. executing a sequence of actions that takes the agent to a state", + "type": "text" + }, + { + "bbox": [ + 451, + 317, + 460, + 326 + ], + "score": 0.84, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 460, + 316, + 505, + 327 + ], + "score": 1.0, + "content": ". She then", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 326, + 506, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 506, + 339 + ], + "score": 1.0, + "content": "outputs a STOP action, which hands control over to Bob. In reversible environments, Bob’s goal is", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 337, + 505, + 349 + ], + "spans": [ + { + "bbox": [ + 106, + 337, + 232, + 349 + ], + "score": 1.0, + "content": "to return the agent back to state", + "type": "text" + }, + { + "bbox": [ + 232, + 338, + 243, + 348 + ], + "score": 0.85, + "content": "s _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 337, + 505, + 349 + ], + "score": 1.0, + "content": "(or within some margin of it, if the state is continuous), to receive", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 349, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 106, + 349, + 506, + 361 + ], + "score": 1.0, + "content": "reward. In partially observable environments, the objective is relaxed to Bob finding a state that", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 360, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 106, + 360, + 505, + 371 + ], + "score": 1.0, + "content": "returns the same observation as Alice’s initial state. In environments where resets are permissible,", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 369, + 504, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 369, + 399, + 383 + ], + "score": 1.0, + "content": "Alice’s STOP action also reinitializes the environment, thus Bob starts at", + "type": "text" + }, + { + "bbox": [ + 399, + 371, + 410, + 381 + ], + "score": 0.85, + "content": "s _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 410, + 369, + 494, + 383 + ], + "score": 1.0, + "content": "and now must reach", + "type": "text" + }, + { + "bbox": [ + 494, + 371, + 504, + 381 + ], + "score": 0.83, + "content": "s _ { t }", + "type": "inline_equation" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 381, + 505, + 393 + ], + "spans": [ + { + "bbox": [ + 106, + 381, + 505, + 393 + ], + "score": 1.0, + "content": "to be rewarded, thus repeating Alice’s task instead of reversing it. See Fig. 1 for an example, and", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 392, + 241, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 241, + 404 + ], + "score": 1.0, + "content": "also Algorithm 1 in Appendix A.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 106, + 408, + 505, + 497 + ], + "lines": [ + { + "bbox": [ + 106, + 409, + 504, + 421 + ], + "spans": [ + { + "bbox": [ + 106, + 409, + 504, + 421 + ], + "score": 1.0, + "content": "In both cases, this self-play between Alice and Bob only involves internal reward (detailed below),", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 420, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 505, + 432 + ], + "score": 1.0, + "content": "thus the agent can be trained without needing any supervisory signal from the environment. As such,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 431, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 431, + 505, + 443 + ], + "score": 1.0, + "content": "it comprises a form of unsupervised training where Alice and Bob explore the environment and learn", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 442, + 506, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 506, + 454 + ], + "score": 1.0, + "content": "how it operates. This exploration can be leveraged for some target task by training Bob on target task", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 452, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 452, + 506, + 466 + ], + "score": 1.0, + "content": "episodes in parallel. The idea is that Bob’s experience from self-play will help him learn the target", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 463, + 506, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 506, + 476 + ], + "score": 1.0, + "content": "task in fewer episodes. The reason behind choosing Bob for the target task is because he learns to", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 475, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 505, + 487 + ], + "score": 1.0, + "content": "transfer from one state to another efficiently from self-play. See Algorithm 2 in Appendix A for", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 485, + 134, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 134, + 497 + ], + "score": 1.0, + "content": "detail.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 31.5 + }, + { + "type": "text", + "bbox": [ + 107, + 502, + 505, + 536 + ], + "lines": [ + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "score": 1.0, + "content": "For self-play, we choose the reward structure for Alice and Bob to encourage Alice to push Bob past", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 514, + 505, + 526 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 450, + 526 + ], + "score": 1.0, + "content": "his comfort zone, but not give him impossible tasks. Denoting Bob’s total reward by", + "type": "text" + }, + { + "bbox": [ + 451, + 514, + 466, + 525 + ], + "score": 0.89, + "content": "R _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 514, + 505, + 526 + ], + "score": 1.0, + "content": "(given at", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 524, + 348, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 524, + 299, + 537 + ], + "score": 1.0, + "content": "the end of episodes) and Alice’s total reward by", + "type": "text" + }, + { + "bbox": [ + 299, + 525, + 314, + 536 + ], + "score": 0.9, + "content": "R _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 524, + 348, + 537 + ], + "score": 1.0, + "content": ", we use", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37 + }, + { + "type": "interline_equation", + "bbox": [ + 278, + 546, + 333, + 559 + ], + "lines": [ + { + "bbox": [ + 278, + 546, + 333, + 559 + ], + "spans": [ + { + "bbox": [ + 278, + 546, + 333, + 559 + ], + "score": 0.91, + "content": "R _ { B } = - \\gamma t _ { B }", + "type": "interline_equation", + "image_path": "82f26d450436f47e2cfc2a1e7bc1d3574f51ebb67f307f2ccfc6734ae342843d.jpg" + } + ] + } + ], + "index": 39, + "virtual_lines": [ + { + "bbox": [ + 278, + 546, + 333, + 559 + ], + "spans": [], + "index": 39 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 570, + 345, + 582 + ], + "lines": [ + { + "bbox": [ + 107, + 569, + 344, + 583 + ], + "spans": [ + { + "bbox": [ + 107, + 569, + 133, + 583 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 571, + 145, + 581 + ], + "score": 0.88, + "content": "t _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 569, + 344, + 583 + ], + "score": 1.0, + "content": "is the time taken by Bob to complete his task and", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "interline_equation", + "bbox": [ + 252, + 592, + 359, + 606 + ], + "lines": [ + { + "bbox": [ + 252, + 592, + 359, + 606 + ], + "spans": [ + { + "bbox": [ + 252, + 592, + 359, + 606 + ], + "score": 0.91, + "content": "R _ { A } = \\gamma \\operatorname* { m a x } ( 0 , t _ { B } - t _ { A } )", + "type": "interline_equation", + "image_path": "8f299b9b9d20e07603d541cd78bc39e3ba805b17de6825d2994dfeb824281cd7.jpg" + } + ] + } + ], + "index": 41, + "virtual_lines": [ + { + "bbox": [ + 252, + 592, + 359, + 606 + ], + "spans": [], + "index": 41 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 615, + 504, + 650 + ], + "lines": [ + { + "bbox": [ + 105, + 615, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 132, + 629 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 617, + 144, + 627 + ], + "score": 0.86, + "content": "t _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 615, + 353, + 629 + ], + "score": 1.0, + "content": "is the time until Alice performs the STOP action, and", + "type": "text" + }, + { + "bbox": [ + 353, + 618, + 361, + 628 + ], + "score": 0.83, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 615, + 505, + 629 + ], + "score": 1.0, + "content": "is a scaling coefficient that balances", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "this internal reward to be of the same scale as external rewards from the target task. The total length", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 637, + 502, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 212, + 651 + ], + "score": 1.0, + "content": "of an episode is limited to", + "type": "text" + }, + { + "bbox": [ + 212, + 639, + 230, + 649 + ], + "score": 0.89, + "content": "t _ { \\mathrm { M a x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 637, + 433, + 651 + ], + "score": 1.0, + "content": ", so if Bob fails to complete the task in time we set", + "type": "text" + }, + { + "bbox": [ + 433, + 639, + 497, + 649 + ], + "score": 0.91, + "content": "t _ { B } = t _ { \\mathrm { M a x } } - t _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 497, + 637, + 502, + 651 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 106, + 654, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 654, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 654, + 505, + 667 + ], + "score": 1.0, + "content": "Thus Alice is rewarded if Bob takes more time, but the negative term on her own time will en-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "courage Alice not to take too many steps when Bob is failing. For both reversible and resettable", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "environments, Alice must limit her steps to make Bob’s task easier, thus Alice’s optimal behavior is", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "score": 1.0, + "content": "to the find simplest tasks that Bob cannot complete. This eases learning for Bob since the new task", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "will be only just beyond his current capabilities. The self-regulating feedback between Alice and", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "Bob allows them to automatically construct a curriculum for exploration, a key contribution of our", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 721, + 147, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 147, + 732 + ], + "score": 1.0, + "content": "approach.", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 48 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published 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": [ + 372, + 79, + 479, + 175 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 372, + 79, + 479, + 175 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 372, + 79, + 479, + 175 + ], + "spans": [ + { + "bbox": [ + 372, + 79, + 479, + 175 + ], + "score": 0.839, + "type": "image", + "image_path": "7a0fb69b8512612d2b8fa5d73a06dd1b5ae9373c04f571492ab24b6a8c9031ad.jpg" + } + ] + } + ], + "index": 7.5, + "virtual_lines": [ + { + "bbox": [ + 372, + 79, + 479, + 127.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 372, + 127.0, + 479, + 175.0 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 387, + 177, + 464, + 184 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 387, + 175, + 465, + 185 + ], + "spans": [ + { + "bbox": [ + 387, + 175, + 465, + 185 + ], + "score": 1.0, + "content": "Bob\tapplied\tto\ttarget\ttask", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + } + ], + "index": 8.75 + }, + { + "type": "image", + "bbox": [ + 129, + 80, + 356, + 183 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 129, + 80, + 356, + 183 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 129, + 80, + 356, + 183 + ], + "spans": [ + { + "bbox": [ + 129, + 80, + 356, + 183 + ], + "score": 0.317, + "type": "image", + "image_path": "77c7cd4ceefc87391c2fd192d27a67f27251053c83d29d18dc2e3330d52f342f.jpg" + } + ] + } + ], + "index": 3.5, + "virtual_lines": [ + { + "bbox": [ + 129, + 80, + 356, + 92.875 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 129, + 92.875, + 356, + 105.75 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 129, + 105.75, + 356, + 118.625 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 129, + 118.625, + 356, + 131.5 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 129, + 131.5, + 356, + 144.375 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 129, + 144.375, + 356, + 157.25 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 129, + 157.25, + 356, + 170.125 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 129, + 170.125, + 356, + 183.0 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 185, + 505, + 273 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 183, + 506, + 198 + ], + "spans": [ + { + "bbox": [ + 105, + 183, + 506, + 198 + ], + "score": 1.0, + "content": "Figure 1: Illustration of the self-play concept in a gridworld setting. Training consists of two types", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 194, + 506, + 208 + ], + "spans": [ + { + "bbox": [ + 105, + 194, + 506, + 208 + ], + "score": 1.0, + "content": "of episode: self-play and target task. In the former, Alice and Bob take turns moving the agent", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 205, + 505, + 219 + ], + "spans": [ + { + "bbox": [ + 106, + 205, + 505, + 219 + ], + "score": 1.0, + "content": "within the environment. Alice sets tasks by altering the state via interaction with its objects (key,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 217, + 505, + 229 + ], + "spans": [ + { + "bbox": [ + 106, + 217, + 505, + 229 + ], + "score": 1.0, + "content": "door, light) and then hands control over to Bob. He must return the environment to its original state", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 227, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 105, + 227, + 505, + 241 + ], + "score": 1.0, + "content": "to receive an internal reward. This task is just one of many devised by Alice, who automatically", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 238, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 505, + 252 + ], + "score": 1.0, + "content": "builds a curriculum of increasingly challenging tasks. In the target task, Bob’s policy is used to", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 251, + 505, + 262 + ], + "spans": [ + { + "bbox": [ + 106, + 251, + 505, + 262 + ], + "score": 1.0, + "content": "control the agent, with him receiving an external reward if he visits the flag. He is able to learn to", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 260, + 415, + 275 + ], + "spans": [ + { + "bbox": [ + 105, + 260, + 415, + 275 + ], + "score": 1.0, + "content": "do this quickly as he is already familiar with the environment from self-play.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14.5 + } + ], + "index": 9.0 + }, + { + "type": "text", + "bbox": [ + 106, + 303, + 505, + 403 + ], + "lines": [], + "index": 23, + "bbox_fs": [ + 105, + 303, + 506, + 404 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 408, + 505, + 497 + ], + "lines": [ + { + "bbox": [ + 106, + 409, + 504, + 421 + ], + "spans": [ + { + "bbox": [ + 106, + 409, + 504, + 421 + ], + "score": 1.0, + "content": "In both cases, this self-play between Alice and Bob only involves internal reward (detailed below),", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 420, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 505, + 432 + ], + "score": 1.0, + "content": "thus the agent can be trained without needing any supervisory signal from the environment. As such,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 431, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 431, + 505, + 443 + ], + "score": 1.0, + "content": "it comprises a form of unsupervised training where Alice and Bob explore the environment and learn", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 442, + 506, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 506, + 454 + ], + "score": 1.0, + "content": "how it operates. This exploration can be leveraged for some target task by training Bob on target task", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 452, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 452, + 506, + 466 + ], + "score": 1.0, + "content": "episodes in parallel. The idea is that Bob’s experience from self-play will help him learn the target", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 463, + 506, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 506, + 476 + ], + "score": 1.0, + "content": "task in fewer episodes. The reason behind choosing Bob for the target task is because he learns to", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 475, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 505, + 487 + ], + "score": 1.0, + "content": "transfer from one state to another efficiently from self-play. See Algorithm 2 in Appendix A for", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 485, + 134, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 134, + 497 + ], + "score": 1.0, + "content": "detail.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 31.5, + "bbox_fs": [ + 105, + 409, + 506, + 497 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 502, + 505, + 536 + ], + "lines": [ + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "score": 1.0, + "content": "For self-play, we choose the reward structure for Alice and Bob to encourage Alice to push Bob past", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 514, + 505, + 526 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 450, + 526 + ], + "score": 1.0, + "content": "his comfort zone, but not give him impossible tasks. Denoting Bob’s total reward by", + "type": "text" + }, + { + "bbox": [ + 451, + 514, + 466, + 525 + ], + "score": 0.89, + "content": "R _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 514, + 505, + 526 + ], + "score": 1.0, + "content": "(given at", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 524, + 348, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 524, + 299, + 537 + ], + "score": 1.0, + "content": "the end of episodes) and Alice’s total reward by", + "type": "text" + }, + { + "bbox": [ + 299, + 525, + 314, + 536 + ], + "score": 0.9, + "content": "R _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 524, + 348, + 537 + ], + "score": 1.0, + "content": ", we use", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37, + "bbox_fs": [ + 105, + 501, + 505, + 537 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 278, + 546, + 333, + 559 + ], + "lines": [ + { + "bbox": [ + 278, + 546, + 333, + 559 + ], + "spans": [ + { + "bbox": [ + 278, + 546, + 333, + 559 + ], + "score": 0.91, + "content": "R _ { B } = - \\gamma t _ { B }", + "type": "interline_equation", + "image_path": "82f26d450436f47e2cfc2a1e7bc1d3574f51ebb67f307f2ccfc6734ae342843d.jpg" + } + ] + } + ], + "index": 39, + "virtual_lines": [ + { + "bbox": [ + 278, + 546, + 333, + 559 + ], + "spans": [], + "index": 39 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 570, + 345, + 582 + ], + "lines": [ + { + "bbox": [ + 107, + 569, + 344, + 583 + ], + "spans": [ + { + "bbox": [ + 107, + 569, + 133, + 583 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 571, + 145, + 581 + ], + "score": 0.88, + "content": "t _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 569, + 344, + 583 + ], + "score": 1.0, + "content": "is the time taken by Bob to complete his task and", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40, + "bbox_fs": [ + 107, + 569, + 344, + 583 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 252, + 592, + 359, + 606 + ], + "lines": [ + { + "bbox": [ + 252, + 592, + 359, + 606 + ], + "spans": [ + { + "bbox": [ + 252, + 592, + 359, + 606 + ], + "score": 0.91, + "content": "R _ { A } = \\gamma \\operatorname* { m a x } ( 0 , t _ { B } - t _ { A } )", + "type": "interline_equation", + "image_path": "8f299b9b9d20e07603d541cd78bc39e3ba805b17de6825d2994dfeb824281cd7.jpg" + } + ] + } + ], + "index": 41, + "virtual_lines": [ + { + "bbox": [ + 252, + 592, + 359, + 606 + ], + "spans": [], + "index": 41 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 615, + 504, + 650 + ], + "lines": [ + { + "bbox": [ + 105, + 615, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 132, + 629 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 617, + 144, + 627 + ], + "score": 0.86, + "content": "t _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 615, + 353, + 629 + ], + "score": 1.0, + "content": "is the time until Alice performs the STOP action, and", + "type": "text" + }, + { + "bbox": [ + 353, + 618, + 361, + 628 + ], + "score": 0.83, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 615, + 505, + 629 + ], + "score": 1.0, + "content": "is a scaling coefficient that balances", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "this internal reward to be of the same scale as external rewards from the target task. The total length", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 637, + 502, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 212, + 651 + ], + "score": 1.0, + "content": "of an episode is limited to", + "type": "text" + }, + { + "bbox": [ + 212, + 639, + 230, + 649 + ], + "score": 0.89, + "content": "t _ { \\mathrm { M a x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 637, + 433, + 651 + ], + "score": 1.0, + "content": ", so if Bob fails to complete the task in time we set", + "type": "text" + }, + { + "bbox": [ + 433, + 639, + 497, + 649 + ], + "score": 0.91, + "content": "t _ { B } = t _ { \\mathrm { M a x } } - t _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 497, + 637, + 502, + 651 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43, + "bbox_fs": [ + 105, + 615, + 505, + 651 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 654, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 654, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 654, + 505, + 667 + ], + "score": 1.0, + "content": "Thus Alice is rewarded if Bob takes more time, but the negative term on her own time will en-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "courage Alice not to take too many steps when Bob is failing. For both reversible and resettable", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "environments, Alice must limit her steps to make Bob’s task easier, thus Alice’s optimal behavior is", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "score": 1.0, + "content": "to the find simplest tasks that Bob cannot complete. This eases learning for Bob since the new task", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "will be only just beyond his current capabilities. The self-regulating feedback between Alice and", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "Bob allows them to automatically construct a curriculum for exploration, a key contribution of our", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 721, + 147, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 147, + 732 + ], + "score": 1.0, + "content": "approach.", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 48, + "bbox_fs": [ + 105, + 654, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 106, + 82, + 331, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 331, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 331, + 95 + ], + "score": 1.0, + "content": "2.1 PARAMETERIZING ALICE AND BOB’S ACTIONS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 105, + 104, + 504, + 127 + ], + "lines": [ + { + "bbox": [ + 106, + 103, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 103, + 505, + 117 + ], + "score": 1.0, + "content": "Alice and Bob each have policy functions which take as input two observations of state variables,", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 115, + 451, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 451, + 127 + ], + "score": 1.0, + "content": "and output a distribution over actions. In Alice’s case, the function will be of the form", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1.5 + }, + { + "type": "interline_equation", + "bbox": [ + 270, + 134, + 340, + 148 + ], + "lines": [ + { + "bbox": [ + 270, + 134, + 340, + 148 + ], + "spans": [ + { + "bbox": [ + 270, + 134, + 340, + 148 + ], + "score": 0.93, + "content": "a _ { \\mathrm { A } } = \\pi _ { A } ( s _ { t } , s _ { 0 } ) ,", + "type": "interline_equation", + "image_path": "6206f692a500e6dc678b0696095753c9602c014a63e60dd2115557c28904a1aa.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 270, + 134, + 340, + 148 + ], + "spans": [], + "index": 3 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 155, + 505, + 178 + ], + "lines": [ + { + "bbox": [ + 106, + 155, + 505, + 168 + ], + "spans": [ + { + "bbox": [ + 106, + 155, + 133, + 168 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 158, + 144, + 167 + ], + "score": 0.84, + "content": "s _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 155, + 393, + 168 + ], + "score": 1.0, + "content": "is the observation of the initial state of the environment and", + "type": "text" + }, + { + "bbox": [ + 393, + 158, + 402, + 167 + ], + "score": 0.84, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 403, + 155, + 505, + 168 + ], + "score": 1.0, + "content": "is the observation of the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 167, + 300, + 178 + ], + "spans": [ + { + "bbox": [ + 106, + 167, + 300, + 178 + ], + "score": 1.0, + "content": "current state. In Bob’s case, the function will be", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "interline_equation", + "bbox": [ + 270, + 186, + 340, + 200 + ], + "lines": [ + { + "bbox": [ + 270, + 186, + 340, + 200 + ], + "spans": [ + { + "bbox": [ + 270, + 186, + 340, + 200 + ], + "score": 0.9, + "content": "a _ { \\mathrm { B } } = \\pi _ { B } ( s _ { t } , s ^ { * } ) ,", + "type": "interline_equation", + "image_path": "9aba1e5411bc784fc3f549e54125284365f7d30fe050f0f4543b9367bf7586b6.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 270, + 186, + 340, + 200 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 207, + 505, + 230 + ], + "lines": [ + { + "bbox": [ + 106, + 207, + 504, + 219 + ], + "spans": [ + { + "bbox": [ + 106, + 207, + 133, + 219 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 208, + 144, + 218 + ], + "score": 0.86, + "content": "s ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 207, + 348, + 219 + ], + "score": 1.0, + "content": "is the target state that Bob has to reach, and set to", + "type": "text" + }, + { + "bbox": [ + 348, + 210, + 359, + 219 + ], + "score": 0.86, + "content": "s _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 359, + 207, + 504, + 219 + ], + "score": 1.0, + "content": "when we have a reversible environ-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 218, + 459, + 231 + ], + "spans": [ + { + "bbox": [ + 105, + 218, + 243, + 231 + ], + "score": 1.0, + "content": "ment. In a resettable environment", + "type": "text" + }, + { + "bbox": [ + 243, + 219, + 253, + 228 + ], + "score": 0.87, + "content": "s ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 218, + 459, + 231 + ], + "score": 1.0, + "content": "is the state where Alice executed the STOP action.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 107, + 235, + 505, + 281 + ], + "lines": [ + { + "bbox": [ + 105, + 235, + 506, + 249 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 353, + 249 + ], + "score": 1.0, + "content": "When a target task is presented, the agent’s policy function is", + "type": "text" + }, + { + "bbox": [ + 353, + 235, + 429, + 248 + ], + "score": 0.93, + "content": "a _ { \\mathrm { T a r g e t } } = \\pi _ { B } ( s _ { t } , \\emptyset )", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 235, + 506, + 249 + ], + "score": 1.0, + "content": ", where the second", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 248, + 506, + 260 + ], + "spans": [ + { + "bbox": [ + 105, + 248, + 312, + 260 + ], + "score": 1.0, + "content": "argument of Bob’s policy is simply set to zero 1. If", + "type": "text" + }, + { + "bbox": [ + 313, + 248, + 323, + 258 + ], + "score": 0.86, + "content": "s ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 248, + 506, + 260 + ], + "score": 1.0, + "content": "is always non-zero, then this is enough to let", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 259, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 477, + 271 + ], + "score": 1.0, + "content": "Bob know whether the current episode is self-play or target task. In some experiments where", + "type": "text" + }, + { + "bbox": [ + 477, + 259, + 487, + 269 + ], + "score": 0.86, + "content": "s ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 259, + 505, + 271 + ], + "score": 1.0, + "content": "can", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 270, + 445, + 282 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 235, + 282 + ], + "score": 1.0, + "content": "be zero, we give third argument", + "type": "text" + }, + { + "bbox": [ + 235, + 270, + 278, + 282 + ], + "score": 0.94, + "content": "z \\in \\{ 0 , 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 270, + 445, + 282 + ], + "score": 1.0, + "content": "that explicitly indicates the episode kind.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 107, + 286, + 505, + 331 + ], + "lines": [ + { + "bbox": [ + 105, + 287, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 408, + 299 + ], + "score": 1.0, + "content": "In the experiments below, we demonstrate our approach in settings where", + "type": "text" + }, + { + "bbox": [ + 408, + 289, + 422, + 298 + ], + "score": 0.86, + "content": "\\pi _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 422, + 287, + 441, + 299 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 442, + 289, + 455, + 298 + ], + "score": 0.85, + "content": "\\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 455, + 287, + 505, + 299 + ], + "score": 1.0, + "content": "are tabular;", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 297, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 505, + 310 + ], + "score": 1.0, + "content": "where it is a neural network taking discrete inputs, and where it is a neural network taking in con-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 309, + 505, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 505, + 321 + ], + "score": 1.0, + "content": "tinuous inputs. When using a neural network, we use the same network architecture for both Alice", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 320, + 297, + 332 + ], + "spans": [ + { + "bbox": [ + 106, + 320, + 297, + 332 + ], + "score": 1.0, + "content": "and Bob, except they have different parameters", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 14.5 + }, + { + "type": "interline_equation", + "bbox": [ + 189, + 339, + 421, + 353 + ], + "lines": [ + { + "bbox": [ + 189, + 339, + 421, + 353 + ], + "spans": [ + { + "bbox": [ + 189, + 339, + 421, + 353 + ], + "score": 0.89, + "content": "\\pi _ { A } ( s _ { t } , s _ { 0 } ) = f ( s _ { t } , s _ { 0 } , \\theta _ { A } ) , \\quad \\pi _ { B } ( s _ { t } , s ^ { \\ast } ) = f ( s _ { t } , s ^ { \\ast } , \\theta _ { B } ) ,", + "type": "interline_equation", + "image_path": "6bd4885786b4ec879bfd5102bce5b22e44dbeac720a64e6be9b91d558556af5f.jpg" + } + ] + } + ], + "index": 17, + "virtual_lines": [ + { + "bbox": [ + 189, + 339, + 421, + 353 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 360, + 389, + 372 + ], + "lines": [ + { + "bbox": [ + 105, + 358, + 389, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 133, + 374 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 361, + 140, + 372 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 358, + 348, + 374 + ], + "score": 1.0, + "content": "is an multi-layered neural network with parameters", + "type": "text" + }, + { + "bbox": [ + 348, + 361, + 360, + 371 + ], + "score": 0.89, + "content": "\\theta _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 358, + 372, + 374 + ], + "score": 1.0, + "content": "or", + "type": "text" + }, + { + "bbox": [ + 372, + 361, + 385, + 371 + ], + "score": 0.89, + "content": "\\theta _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 358, + 389, + 374 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "title", + "bbox": [ + 107, + 388, + 318, + 399 + ], + "lines": [ + { + "bbox": [ + 106, + 388, + 319, + 401 + ], + "spans": [ + { + "bbox": [ + 106, + 388, + 319, + 401 + ], + "score": 1.0, + "content": "2.2 UNIVERSAL BOB IN THE TABULAR SETTING", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 409, + 505, + 443 + ], + "lines": [ + { + "bbox": [ + 106, + 410, + 505, + 422 + ], + "spans": [ + { + "bbox": [ + 106, + 410, + 505, + 422 + ], + "score": 1.0, + "content": "We now present a theoretical argument that shows for environments with finite states, tabular poli-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 420, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 105, + 420, + 505, + 433 + ], + "score": 1.0, + "content": "cies, and deterministic, Markovian transitions, we can interpret the self-play as training Bob to find", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 431, + 451, + 446 + ], + "spans": [ + { + "bbox": [ + 105, + 431, + 451, + 446 + ], + "score": 1.0, + "content": "a policy that can get from any state to any other in the least expected number of steps.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 106, + 448, + 505, + 547 + ], + "lines": [ + { + "bbox": [ + 105, + 448, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 455, + 461 + ], + "score": 1.0, + "content": "Preliminaries: Note that, as discussed above, the policy table for Bob is indexed by", + "type": "text" + }, + { + "bbox": [ + 455, + 448, + 485, + 461 + ], + "score": 0.92, + "content": "( s _ { t } , s ^ { * } )", + "type": "inline_equation" + }, + { + "bbox": [ + 485, + 448, + 505, + 461 + ], + "score": 1.0, + "content": ", not", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 459, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 136, + 473 + ], + "score": 1.0, + "content": "just by", + "type": "text" + }, + { + "bbox": [ + 136, + 461, + 145, + 471 + ], + "score": 0.82, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 459, + 465, + 473 + ], + "score": 1.0, + "content": ". In particular, with the assumptions above, this means that there is a fast policy", + "type": "text" + }, + { + "bbox": [ + 466, + 461, + 483, + 471 + ], + "score": 0.87, + "content": "\\pi _ { \\mathrm { f a s t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 459, + 506, + 473 + ], + "score": 1.0, + "content": "such", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 470, + 506, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 124, + 483 + ], + "score": 1.0, + "content": "that", + "type": "text" + }, + { + "bbox": [ + 124, + 471, + 171, + 483 + ], + "score": 0.93, + "content": "\\pi _ { \\mathrm { f a s t } } ( s _ { t } , s ^ { * } )", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 470, + 412, + 483 + ], + "score": 1.0, + "content": "has the smallest expected number of steps to transition from", + "type": "text" + }, + { + "bbox": [ + 413, + 472, + 422, + 482 + ], + "score": 0.84, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 470, + 433, + 483 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 433, + 471, + 443, + 481 + ], + "score": 0.85, + "content": "s ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 470, + 506, + 483 + ], + "score": 1.0, + "content": ". It is clear that", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 481, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 106, + 483, + 124, + 492 + ], + "score": 0.86, + "content": "\\pi _ { \\mathrm { f a s t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 124, + 481, + 281, + 495 + ], + "score": 1.0, + "content": "is a universal policy for Bob, such that", + "type": "text" + }, + { + "bbox": [ + 282, + 483, + 325, + 492 + ], + "score": 0.9, + "content": "\\pi _ { B } = \\pi _ { \\mathrm { f a s t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 326, + 481, + 505, + 495 + ], + "score": 1.0, + "content": "is optimal with respect to any Alice’s policy", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 107, + 493, + 506, + 506 + ], + "spans": [ + { + "bbox": [ + 107, + 495, + 120, + 504 + ], + "score": 0.84, + "content": "\\pi _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 120, + 493, + 189, + 506 + ], + "score": 1.0, + "content": ". In a reset game,", + "type": "text" + }, + { + "bbox": [ + 190, + 494, + 207, + 504 + ], + "score": 0.87, + "content": "\\pi _ { \\mathrm { f a s t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 493, + 455, + 506 + ], + "score": 1.0, + "content": "nets Alice a return of 0, and in the reverse game, the return of", + "type": "text" + }, + { + "bbox": [ + 456, + 494, + 473, + 504 + ], + "score": 0.87, + "content": "\\pi _ { \\mathrm { f a s t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 474, + 493, + 506, + 506 + ], + "score": 1.0, + "content": "against", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 504, + 504, + 515 + ], + "spans": [ + { + "bbox": [ + 106, + 504, + 504, + 515 + ], + "score": 1.0, + "content": "an optimal Alice can be considered a measure of the reversibility of the environment. However, in", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 515, + 505, + 527 + ], + "spans": [ + { + "bbox": [ + 106, + 515, + 505, + 527 + ], + "score": 1.0, + "content": "what follows let us assume that either the reset game or the reverse game in a perfectly reversible", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 524, + 506, + 538 + ], + "spans": [ + { + "bbox": [ + 104, + 524, + 506, + 538 + ], + "score": 1.0, + "content": "environment is used. Also, let assume the initial states are randomized and its distribution covers", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 537, + 194, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 194, + 549 + ], + "score": 1.0, + "content": "the entire state space.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 552, + 503, + 576 + ], + "lines": [ + { + "bbox": [ + 106, + 552, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 552, + 150, + 565 + ], + "score": 1.0, + "content": "Claim: If", + "type": "text" + }, + { + "bbox": [ + 150, + 554, + 164, + 564 + ], + "score": 0.87, + "content": "\\pi _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 552, + 183, + 565 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 183, + 555, + 197, + 564 + ], + "score": 0.87, + "content": "\\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 552, + 505, + 565 + ], + "score": 1.0, + "content": "are policies of Alice and Bob that are in equilibrium (i.e., Alice cannot be", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 563, + 412, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 335, + 577 + ], + "score": 1.0, + "content": "made better without changing Bob, and vice-versa), then", + "type": "text" + }, + { + "bbox": [ + 335, + 566, + 348, + 575 + ], + "score": 0.85, + "content": "\\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 563, + 412, + 577 + ], + "score": 1.0, + "content": "is a fast policy.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 107, + 581, + 505, + 625 + ], + "lines": [ + { + "bbox": [ + 105, + 581, + 506, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 506, + 594 + ], + "score": 1.0, + "content": "Argument: Let us first show that Alice will always get zero reward in equilibrium. If Alice is", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "score": 1.0, + "content": "getting positive reward on some challenge, that means Bob is taking longer than Alice on that chal-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 603, + 505, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 272, + 616 + ], + "score": 1.0, + "content": "lenge. Then Bob can be improved to use", + "type": "text" + }, + { + "bbox": [ + 272, + 605, + 295, + 615 + ], + "score": 0.89, + "content": "\\pi _ { f a s t }", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 603, + 505, + 616 + ], + "score": 1.0, + "content": "at that challenge, which contradicts the equilibrium", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 614, + 158, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 158, + 626 + ], + "score": 1.0, + "content": "assumption.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 107, + 630, + 505, + 708 + ], + "lines": [ + { + "bbox": [ + 105, + 630, + 506, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 182, + 644 + ], + "score": 1.0, + "content": "Now let us prove", + "type": "text" + }, + { + "bbox": [ + 182, + 633, + 196, + 642 + ], + "score": 0.85, + "content": "\\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 630, + 351, + 644 + ], + "score": 1.0, + "content": "is a fast policy by contradiction. If", + "type": "text" + }, + { + "bbox": [ + 351, + 632, + 365, + 642 + ], + "score": 0.85, + "content": "\\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 630, + 506, + 644 + ], + "score": 1.0, + "content": "is not fast, then there must exist", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 641, + 506, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 156, + 655 + ], + "score": 1.0, + "content": "a challenge", + "type": "text" + }, + { + "bbox": [ + 157, + 642, + 187, + 654 + ], + "score": 0.92, + "content": "( s _ { t } , s ^ { * } )", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 641, + 217, + 655 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 218, + 644, + 231, + 653 + ], + "score": 0.85, + "content": "\\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 232, + 641, + 323, + 655 + ], + "score": 1.0, + "content": "will take longer than", + "type": "text" + }, + { + "bbox": [ + 323, + 644, + 346, + 654 + ], + "score": 0.9, + "content": "\\pi _ { f a s t }", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 641, + 506, + 655 + ], + "score": 1.0, + "content": ". Therefore Bob can get more reward", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 652, + 506, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 144, + 666 + ], + "score": 1.0, + "content": "by using", + "type": "text" + }, + { + "bbox": [ + 144, + 654, + 167, + 665 + ], + "score": 0.9, + "content": "\\pi _ { f a s t }", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 652, + 506, + 666 + ], + "score": 1.0, + "content": "if Alice does propose that challenge with non-zero probability. Since we assumed", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 664, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 173, + 677 + ], + "score": 1.0, + "content": "equilibrium and", + "type": "text" + }, + { + "bbox": [ + 173, + 666, + 187, + 675 + ], + "score": 0.86, + "content": "\\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 664, + 297, + 677 + ], + "score": 1.0, + "content": "cannot be improved while", + "type": "text" + }, + { + "bbox": [ + 297, + 665, + 311, + 675 + ], + "score": 0.86, + "content": "\\pi _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 664, + 505, + 677 + ], + "score": 1.0, + "content": "fixed, the only possibility is that Alice is never", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 675, + 505, + 688 + ], + "spans": [ + { + "bbox": [ + 105, + 675, + 505, + 688 + ], + "score": 1.0, + "content": "proposing that challenge. If that is true, Alice can get positive reward by proposing that task using", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 685, + 507, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 685, + 187, + 700 + ], + "score": 1.0, + "content": "the same actions as", + "type": "text" + }, + { + "bbox": [ + 187, + 688, + 210, + 698 + ], + "score": 0.88, + "content": "\\pi _ { f a s t }", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 685, + 322, + 700 + ], + "score": 1.0, + "content": ", so taking fewer steps than", + "type": "text" + }, + { + "bbox": [ + 323, + 687, + 336, + 697 + ], + "score": 0.85, + "content": "\\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 685, + 507, + 700 + ], + "score": 1.0, + "content": ". However this contradicts with the proof", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 695, + 466, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 695, + 370, + 711 + ], + "score": 1.0, + "content": "that Alice always gets zero reward, making our initial assumption", + "type": "text" + }, + { + "bbox": [ + 370, + 697, + 388, + 708 + ], + "score": 0.88, + "content": "^ { 6 6 } \\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 695, + 466, + 711 + ], + "score": 1.0, + "content": "is not fast” wrong.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 41 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 26, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 117, + 721, + 440, + 732 + ], + "lines": [ + { + "bbox": [ + 119, + 719, + 439, + 734 + ], + "spans": [ + { + "bbox": [ + 119, + 719, + 427, + 734 + ], + "score": 1.0, + "content": "1Note that Bob can be used in multi-task learning by feeding the task description into", + "type": "text" + }, + { + "bbox": [ + 428, + 723, + 439, + 731 + ], + "score": 0.78, + "content": "\\pi _ { B }", + "type": "inline_equation" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 106, + 82, + 331, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 331, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 331, + 95 + ], + "score": 1.0, + "content": "2.1 PARAMETERIZING ALICE AND BOB’S ACTIONS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 105, + 104, + 504, + 127 + ], + "lines": [ + { + "bbox": [ + 106, + 103, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 103, + 505, + 117 + ], + "score": 1.0, + "content": "Alice and Bob each have policy functions which take as input two observations of state variables,", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 115, + 451, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 451, + 127 + ], + "score": 1.0, + "content": "and output a distribution over actions. In Alice’s case, the function will be of the form", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1.5, + "bbox_fs": [ + 106, + 103, + 505, + 127 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 270, + 134, + 340, + 148 + ], + "lines": [ + { + "bbox": [ + 270, + 134, + 340, + 148 + ], + "spans": [ + { + "bbox": [ + 270, + 134, + 340, + 148 + ], + "score": 0.93, + "content": "a _ { \\mathrm { A } } = \\pi _ { A } ( s _ { t } , s _ { 0 } ) ,", + "type": "interline_equation", + "image_path": "6206f692a500e6dc678b0696095753c9602c014a63e60dd2115557c28904a1aa.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 270, + 134, + 340, + 148 + ], + "spans": [], + "index": 3 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 155, + 505, + 178 + ], + "lines": [ + { + "bbox": [ + 106, + 155, + 505, + 168 + ], + "spans": [ + { + "bbox": [ + 106, + 155, + 133, + 168 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 158, + 144, + 167 + ], + "score": 0.84, + "content": "s _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 155, + 393, + 168 + ], + "score": 1.0, + "content": "is the observation of the initial state of the environment and", + "type": "text" + }, + { + "bbox": [ + 393, + 158, + 402, + 167 + ], + "score": 0.84, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 403, + 155, + 505, + 168 + ], + "score": 1.0, + "content": "is the observation of the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 167, + 300, + 178 + ], + "spans": [ + { + "bbox": [ + 106, + 167, + 300, + 178 + ], + "score": 1.0, + "content": "current state. In Bob’s case, the function will be", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5, + "bbox_fs": [ + 106, + 155, + 505, + 178 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 270, + 186, + 340, + 200 + ], + "lines": [ + { + "bbox": [ + 270, + 186, + 340, + 200 + ], + "spans": [ + { + "bbox": [ + 270, + 186, + 340, + 200 + ], + "score": 0.9, + "content": "a _ { \\mathrm { B } } = \\pi _ { B } ( s _ { t } , s ^ { * } ) ,", + "type": "interline_equation", + "image_path": "9aba1e5411bc784fc3f549e54125284365f7d30fe050f0f4543b9367bf7586b6.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 270, + 186, + 340, + 200 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 207, + 505, + 230 + ], + "lines": [ + { + "bbox": [ + 106, + 207, + 504, + 219 + ], + "spans": [ + { + "bbox": [ + 106, + 207, + 133, + 219 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 208, + 144, + 218 + ], + "score": 0.86, + "content": "s ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 207, + 348, + 219 + ], + "score": 1.0, + "content": "is the target state that Bob has to reach, and set to", + "type": "text" + }, + { + "bbox": [ + 348, + 210, + 359, + 219 + ], + "score": 0.86, + "content": "s _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 359, + 207, + 504, + 219 + ], + "score": 1.0, + "content": "when we have a reversible environ-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 218, + 459, + 231 + ], + "spans": [ + { + "bbox": [ + 105, + 218, + 243, + 231 + ], + "score": 1.0, + "content": "ment. In a resettable environment", + "type": "text" + }, + { + "bbox": [ + 243, + 219, + 253, + 228 + ], + "score": 0.87, + "content": "s ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 218, + 459, + 231 + ], + "score": 1.0, + "content": "is the state where Alice executed the STOP action.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5, + "bbox_fs": [ + 105, + 207, + 504, + 231 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 235, + 505, + 281 + ], + "lines": [ + { + "bbox": [ + 105, + 235, + 506, + 249 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 353, + 249 + ], + "score": 1.0, + "content": "When a target task is presented, the agent’s policy function is", + "type": "text" + }, + { + "bbox": [ + 353, + 235, + 429, + 248 + ], + "score": 0.93, + "content": "a _ { \\mathrm { T a r g e t } } = \\pi _ { B } ( s _ { t } , \\emptyset )", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 235, + 506, + 249 + ], + "score": 1.0, + "content": ", where the second", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 248, + 506, + 260 + ], + "spans": [ + { + "bbox": [ + 105, + 248, + 312, + 260 + ], + "score": 1.0, + "content": "argument of Bob’s policy is simply set to zero 1. If", + "type": "text" + }, + { + "bbox": [ + 313, + 248, + 323, + 258 + ], + "score": 0.86, + "content": "s ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 248, + 506, + 260 + ], + "score": 1.0, + "content": "is always non-zero, then this is enough to let", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 259, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 477, + 271 + ], + "score": 1.0, + "content": "Bob know whether the current episode is self-play or target task. In some experiments where", + "type": "text" + }, + { + "bbox": [ + 477, + 259, + 487, + 269 + ], + "score": 0.86, + "content": "s ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 259, + 505, + 271 + ], + "score": 1.0, + "content": "can", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 270, + 445, + 282 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 235, + 282 + ], + "score": 1.0, + "content": "be zero, we give third argument", + "type": "text" + }, + { + "bbox": [ + 235, + 270, + 278, + 282 + ], + "score": 0.94, + "content": "z \\in \\{ 0 , 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 270, + 445, + 282 + ], + "score": 1.0, + "content": "that explicitly indicates the episode kind.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 235, + 506, + 282 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 286, + 505, + 331 + ], + "lines": [ + { + "bbox": [ + 105, + 287, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 408, + 299 + ], + "score": 1.0, + "content": "In the experiments below, we demonstrate our approach in settings where", + "type": "text" + }, + { + "bbox": [ + 408, + 289, + 422, + 298 + ], + "score": 0.86, + "content": "\\pi _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 422, + 287, + 441, + 299 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 442, + 289, + 455, + 298 + ], + "score": 0.85, + "content": "\\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 455, + 287, + 505, + 299 + ], + "score": 1.0, + "content": "are tabular;", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 297, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 505, + 310 + ], + "score": 1.0, + "content": "where it is a neural network taking discrete inputs, and where it is a neural network taking in con-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 309, + 505, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 505, + 321 + ], + "score": 1.0, + "content": "tinuous inputs. When using a neural network, we use the same network architecture for both Alice", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 320, + 297, + 332 + ], + "spans": [ + { + "bbox": [ + 106, + 320, + 297, + 332 + ], + "score": 1.0, + "content": "and Bob, except they have different parameters", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 14.5, + "bbox_fs": [ + 105, + 287, + 505, + 332 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 189, + 339, + 421, + 353 + ], + "lines": [ + { + "bbox": [ + 189, + 339, + 421, + 353 + ], + "spans": [ + { + "bbox": [ + 189, + 339, + 421, + 353 + ], + "score": 0.89, + "content": "\\pi _ { A } ( s _ { t } , s _ { 0 } ) = f ( s _ { t } , s _ { 0 } , \\theta _ { A } ) , \\quad \\pi _ { B } ( s _ { t } , s ^ { \\ast } ) = f ( s _ { t } , s ^ { \\ast } , \\theta _ { B } ) ,", + "type": "interline_equation", + "image_path": "6bd4885786b4ec879bfd5102bce5b22e44dbeac720a64e6be9b91d558556af5f.jpg" + } + ] + } + ], + "index": 17, + "virtual_lines": [ + { + "bbox": [ + 189, + 339, + 421, + 353 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 360, + 389, + 372 + ], + "lines": [ + { + "bbox": [ + 105, + 358, + 389, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 133, + 374 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 361, + 140, + 372 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 358, + 348, + 374 + ], + "score": 1.0, + "content": "is an multi-layered neural network with parameters", + "type": "text" + }, + { + "bbox": [ + 348, + 361, + 360, + 371 + ], + "score": 0.89, + "content": "\\theta _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 358, + 372, + 374 + ], + "score": 1.0, + "content": "or", + "type": "text" + }, + { + "bbox": [ + 372, + 361, + 385, + 371 + ], + "score": 0.89, + "content": "\\theta _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 358, + 389, + 374 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 358, + 389, + 374 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 388, + 318, + 399 + ], + "lines": [ + { + "bbox": [ + 106, + 388, + 319, + 401 + ], + "spans": [ + { + "bbox": [ + 106, + 388, + 319, + 401 + ], + "score": 1.0, + "content": "2.2 UNIVERSAL BOB IN THE TABULAR SETTING", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 409, + 505, + 443 + ], + "lines": [ + { + "bbox": [ + 106, + 410, + 505, + 422 + ], + "spans": [ + { + "bbox": [ + 106, + 410, + 505, + 422 + ], + "score": 1.0, + "content": "We now present a theoretical argument that shows for environments with finite states, tabular poli-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 420, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 105, + 420, + 505, + 433 + ], + "score": 1.0, + "content": "cies, and deterministic, Markovian transitions, we can interpret the self-play as training Bob to find", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 431, + 451, + 446 + ], + "spans": [ + { + "bbox": [ + 105, + 431, + 451, + 446 + ], + "score": 1.0, + "content": "a policy that can get from any state to any other in the least expected number of steps.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 410, + 505, + 446 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 448, + 505, + 547 + ], + "lines": [ + { + "bbox": [ + 105, + 448, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 455, + 461 + ], + "score": 1.0, + "content": "Preliminaries: Note that, as discussed above, the policy table for Bob is indexed by", + "type": "text" + }, + { + "bbox": [ + 455, + 448, + 485, + 461 + ], + "score": 0.92, + "content": "( s _ { t } , s ^ { * } )", + "type": "inline_equation" + }, + { + "bbox": [ + 485, + 448, + 505, + 461 + ], + "score": 1.0, + "content": ", not", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 459, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 136, + 473 + ], + "score": 1.0, + "content": "just by", + "type": "text" + }, + { + "bbox": [ + 136, + 461, + 145, + 471 + ], + "score": 0.82, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 459, + 465, + 473 + ], + "score": 1.0, + "content": ". In particular, with the assumptions above, this means that there is a fast policy", + "type": "text" + }, + { + "bbox": [ + 466, + 461, + 483, + 471 + ], + "score": 0.87, + "content": "\\pi _ { \\mathrm { f a s t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 459, + 506, + 473 + ], + "score": 1.0, + "content": "such", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 470, + 506, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 124, + 483 + ], + "score": 1.0, + "content": "that", + "type": "text" + }, + { + "bbox": [ + 124, + 471, + 171, + 483 + ], + "score": 0.93, + "content": "\\pi _ { \\mathrm { f a s t } } ( s _ { t } , s ^ { * } )", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 470, + 412, + 483 + ], + "score": 1.0, + "content": "has the smallest expected number of steps to transition from", + "type": "text" + }, + { + "bbox": [ + 413, + 472, + 422, + 482 + ], + "score": 0.84, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 470, + 433, + 483 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 433, + 471, + 443, + 481 + ], + "score": 0.85, + "content": "s ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 470, + 506, + 483 + ], + "score": 1.0, + "content": ". It is clear that", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 481, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 106, + 483, + 124, + 492 + ], + "score": 0.86, + "content": "\\pi _ { \\mathrm { f a s t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 124, + 481, + 281, + 495 + ], + "score": 1.0, + "content": "is a universal policy for Bob, such that", + "type": "text" + }, + { + "bbox": [ + 282, + 483, + 325, + 492 + ], + "score": 0.9, + "content": "\\pi _ { B } = \\pi _ { \\mathrm { f a s t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 326, + 481, + 505, + 495 + ], + "score": 1.0, + "content": "is optimal with respect to any Alice’s policy", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 107, + 493, + 506, + 506 + ], + "spans": [ + { + "bbox": [ + 107, + 495, + 120, + 504 + ], + "score": 0.84, + "content": "\\pi _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 120, + 493, + 189, + 506 + ], + "score": 1.0, + "content": ". In a reset game,", + "type": "text" + }, + { + "bbox": [ + 190, + 494, + 207, + 504 + ], + "score": 0.87, + "content": "\\pi _ { \\mathrm { f a s t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 493, + 455, + 506 + ], + "score": 1.0, + "content": "nets Alice a return of 0, and in the reverse game, the return of", + "type": "text" + }, + { + "bbox": [ + 456, + 494, + 473, + 504 + ], + "score": 0.87, + "content": "\\pi _ { \\mathrm { f a s t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 474, + 493, + 506, + 506 + ], + "score": 1.0, + "content": "against", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 504, + 504, + 515 + ], + "spans": [ + { + "bbox": [ + 106, + 504, + 504, + 515 + ], + "score": 1.0, + "content": "an optimal Alice can be considered a measure of the reversibility of the environment. However, in", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 515, + 505, + 527 + ], + "spans": [ + { + "bbox": [ + 106, + 515, + 505, + 527 + ], + "score": 1.0, + "content": "what follows let us assume that either the reset game or the reverse game in a perfectly reversible", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 524, + 506, + 538 + ], + "spans": [ + { + "bbox": [ + 104, + 524, + 506, + 538 + ], + "score": 1.0, + "content": "environment is used. Also, let assume the initial states are randomized and its distribution covers", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 537, + 194, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 194, + 549 + ], + "score": 1.0, + "content": "the entire state space.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 27, + "bbox_fs": [ + 104, + 448, + 506, + 549 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 552, + 503, + 576 + ], + "lines": [ + { + "bbox": [ + 106, + 552, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 552, + 150, + 565 + ], + "score": 1.0, + "content": "Claim: If", + "type": "text" + }, + { + "bbox": [ + 150, + 554, + 164, + 564 + ], + "score": 0.87, + "content": "\\pi _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 552, + 183, + 565 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 183, + 555, + 197, + 564 + ], + "score": 0.87, + "content": "\\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 552, + 505, + 565 + ], + "score": 1.0, + "content": "are policies of Alice and Bob that are in equilibrium (i.e., Alice cannot be", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 563, + 412, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 335, + 577 + ], + "score": 1.0, + "content": "made better without changing Bob, and vice-versa), then", + "type": "text" + }, + { + "bbox": [ + 335, + 566, + 348, + 575 + ], + "score": 0.85, + "content": "\\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 563, + 412, + 577 + ], + "score": 1.0, + "content": "is a fast policy.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 552, + 505, + 577 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 581, + 505, + 625 + ], + "lines": [ + { + "bbox": [ + 105, + 581, + 506, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 506, + 594 + ], + "score": 1.0, + "content": "Argument: Let us first show that Alice will always get zero reward in equilibrium. If Alice is", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "score": 1.0, + "content": "getting positive reward on some challenge, that means Bob is taking longer than Alice on that chal-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 603, + 505, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 272, + 616 + ], + "score": 1.0, + "content": "lenge. Then Bob can be improved to use", + "type": "text" + }, + { + "bbox": [ + 272, + 605, + 295, + 615 + ], + "score": 0.89, + "content": "\\pi _ { f a s t }", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 603, + 505, + 616 + ], + "score": 1.0, + "content": "at that challenge, which contradicts the equilibrium", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 614, + 158, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 158, + 626 + ], + "score": 1.0, + "content": "assumption.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 581, + 506, + 626 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 630, + 505, + 708 + ], + "lines": [ + { + "bbox": [ + 105, + 630, + 506, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 182, + 644 + ], + "score": 1.0, + "content": "Now let us prove", + "type": "text" + }, + { + "bbox": [ + 182, + 633, + 196, + 642 + ], + "score": 0.85, + "content": "\\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 630, + 351, + 644 + ], + "score": 1.0, + "content": "is a fast policy by contradiction. If", + "type": "text" + }, + { + "bbox": [ + 351, + 632, + 365, + 642 + ], + "score": 0.85, + "content": "\\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 630, + 506, + 644 + ], + "score": 1.0, + "content": "is not fast, then there must exist", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 641, + 506, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 156, + 655 + ], + "score": 1.0, + "content": "a challenge", + "type": "text" + }, + { + "bbox": [ + 157, + 642, + 187, + 654 + ], + "score": 0.92, + "content": "( s _ { t } , s ^ { * } )", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 641, + 217, + 655 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 218, + 644, + 231, + 653 + ], + "score": 0.85, + "content": "\\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 232, + 641, + 323, + 655 + ], + "score": 1.0, + "content": "will take longer than", + "type": "text" + }, + { + "bbox": [ + 323, + 644, + 346, + 654 + ], + "score": 0.9, + "content": "\\pi _ { f a s t }", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 641, + 506, + 655 + ], + "score": 1.0, + "content": ". Therefore Bob can get more reward", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 652, + 506, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 144, + 666 + ], + "score": 1.0, + "content": "by using", + "type": "text" + }, + { + "bbox": [ + 144, + 654, + 167, + 665 + ], + "score": 0.9, + "content": "\\pi _ { f a s t }", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 652, + 506, + 666 + ], + "score": 1.0, + "content": "if Alice does propose that challenge with non-zero probability. Since we assumed", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 664, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 173, + 677 + ], + "score": 1.0, + "content": "equilibrium and", + "type": "text" + }, + { + "bbox": [ + 173, + 666, + 187, + 675 + ], + "score": 0.86, + "content": "\\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 664, + 297, + 677 + ], + "score": 1.0, + "content": "cannot be improved while", + "type": "text" + }, + { + "bbox": [ + 297, + 665, + 311, + 675 + ], + "score": 0.86, + "content": "\\pi _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 664, + 505, + 677 + ], + "score": 1.0, + "content": "fixed, the only possibility is that Alice is never", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 675, + 505, + 688 + ], + "spans": [ + { + "bbox": [ + 105, + 675, + 505, + 688 + ], + "score": 1.0, + "content": "proposing that challenge. If that is true, Alice can get positive reward by proposing that task using", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 685, + 507, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 685, + 187, + 700 + ], + "score": 1.0, + "content": "the same actions as", + "type": "text" + }, + { + "bbox": [ + 187, + 688, + 210, + 698 + ], + "score": 0.88, + "content": "\\pi _ { f a s t }", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 685, + 322, + 700 + ], + "score": 1.0, + "content": ", so taking fewer steps than", + "type": "text" + }, + { + "bbox": [ + 323, + 687, + 336, + 697 + ], + "score": 0.85, + "content": "\\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 685, + 507, + 700 + ], + "score": 1.0, + "content": ". However this contradicts with the proof", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 695, + 466, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 695, + 370, + 711 + ], + "score": 1.0, + "content": "that Alice always gets zero reward, making our initial assumption", + "type": "text" + }, + { + "bbox": [ + 370, + 697, + 388, + 708 + ], + "score": 0.88, + "content": "^ { 6 6 } \\pi _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 695, + 466, + 711 + ], + "score": 1.0, + "content": "is not fast” wrong.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 41, + "bbox_fs": [ + 105, + 630, + 507, + 711 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 210, + 93 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 213, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 213, + 95 + ], + "score": 1.0, + "content": "3 RELATED WORK", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 125, + 505, + 191 + ], + "lines": [ + { + "bbox": [ + 105, + 126, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 505, + 138 + ], + "score": 1.0, + "content": "Self-play arises naturally in reinforcement learning, and has been well studied. For example, for", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 137, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 505, + 150 + ], + "score": 1.0, + "content": "playing checkers (Samuel, 1959), backgammon (Tesauro, 1995), and Go, (Silver et al., 2016), and", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 147, + 505, + 160 + ], + "spans": [ + { + "bbox": [ + 105, + 147, + 505, + 160 + ], + "score": 1.0, + "content": "in multi-agent games such as RoboSoccer (Riedmiller et al., 2009). Here, the agents or teams", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 159, + 504, + 172 + ], + "spans": [ + { + "bbox": [ + 106, + 159, + 504, + 172 + ], + "score": 1.0, + "content": "of agents compete for external reward. This differs from our scheme where the reward is purely", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 168, + 506, + 183 + ], + "spans": [ + { + "bbox": [ + 105, + 168, + 506, + 183 + ], + "score": 1.0, + "content": "internal and the self-play is a way of motivating an agent to learn about its environment to augment", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 181, + 275, + 193 + ], + "spans": [ + { + "bbox": [ + 105, + 181, + 275, + 193 + ], + "score": 1.0, + "content": "sparse rewards from separate target tasks.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 197, + 505, + 307 + ], + "lines": [ + { + "bbox": [ + 105, + 198, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 505, + 210 + ], + "score": 1.0, + "content": "Our approach has some relationships with generative adversarial networks (GANs) (Goodfellow", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 208, + 505, + 221 + ], + "spans": [ + { + "bbox": [ + 105, + 208, + 505, + 221 + ], + "score": 1.0, + "content": "et al., 2014), which train a generative neural net by having it try to fool a discriminator network", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 219, + 505, + 232 + ], + "spans": [ + { + "bbox": [ + 105, + 219, + 505, + 232 + ], + "score": 1.0, + "content": "which tries to differentiate samples from the training examples. Li et al. (2017) introduce an adver-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 231, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 505, + 243 + ], + "score": 1.0, + "content": "sarial approach to dialogue generation, where a generator model is subjected to a form of “Turing", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 241, + 505, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 505, + 254 + ], + "score": 1.0, + "content": "test” by a discriminator network. Mescheder et al. (2017) demonstrate how adversarial loss terms", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 253, + 505, + 264 + ], + "spans": [ + { + "bbox": [ + 106, + 253, + 505, + 264 + ], + "score": 1.0, + "content": "can be combined with variational auto-encoders to permit more accurate density modeling. While", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "score": 1.0, + "content": "GAN’s are often thought of as methods for training a generator, the generator can be thought of as", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 274, + 505, + 287 + ], + "spans": [ + { + "bbox": [ + 105, + 274, + 505, + 287 + ], + "score": 1.0, + "content": "a method for generating hard negatives for the discriminator. From this viewpoint, in our approach,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 286, + 505, + 297 + ], + "spans": [ + { + "bbox": [ + 106, + 286, + 505, + 297 + ], + "score": 1.0, + "content": "Alice acts as a “generator”, finding “negatives” for Bob. However, Bob’s jobs is to complete the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 296, + 279, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 279, + 308 + ], + "score": 1.0, + "content": "generated challenge, not to discriminate it.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 107, + 313, + 505, + 489 + ], + "lines": [ + { + "bbox": [ + 106, + 313, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 106, + 313, + 505, + 326 + ], + "score": 1.0, + "content": "There is a large body of work on intrinsic motivation (Barto, 2013; Singh et al., 2004; Klyubin", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 324, + 505, + 337 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 505, + 337 + ], + "score": 1.0, + "content": "et al., 2005; Schmidhuber, 1991) for self-supervised learning agents. These works propose methods", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 335, + 506, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 506, + 348 + ], + "score": 1.0, + "content": "for training an agent to explore and become proficient at manipulating its environment without", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 347, + 505, + 359 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 505, + 359 + ], + "score": 1.0, + "content": "necessarily having a specific target task, and without a source of extrinsic supervision. One line in", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 357, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 357, + 505, + 369 + ], + "score": 1.0, + "content": "this direction is curiosity-driven exploration (Schmidhuber, 1991). These techniques can be applied", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 367, + 505, + 381 + ], + "spans": [ + { + "bbox": [ + 104, + 367, + 505, + 381 + ], + "score": 1.0, + "content": "in encouraging exploration in the context of reinforcement learning, for example (Bellemare et al.,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 377, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 377, + 505, + 392 + ], + "score": 1.0, + "content": "2016; Strehl & Littman, 2008; Lopes et al., 2012; Tang et al., 2016; Pathak et al., 2017); Roughly,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 390, + 505, + 402 + ], + "spans": [ + { + "bbox": [ + 105, + 390, + 505, + 402 + ], + "score": 1.0, + "content": "these use some notion of the novelty of a state to give a reward. In the simplest setting, novelty can", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 401, + 506, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 506, + 413 + ], + "score": 1.0, + "content": "be just the number of times a state has been visited; in more complex scenarios, the agent can build", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 412, + 506, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 506, + 424 + ], + "score": 1.0, + "content": "a model of the world, and the novelty is the difficulty in placing the current state into the model. In", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 423, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 505, + 434 + ], + "score": 1.0, + "content": "our work, there is no explicit notion of novelty. Even if Bob has seen a state many times, if he has", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 433, + 506, + 446 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 506, + 446 + ], + "score": 1.0, + "content": "trouble getting to it, Alice should force him towards that state. Another line of work on intrinsic", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 445, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 505, + 456 + ], + "score": 1.0, + "content": "motivation is a formalization of the notion of empowerment (Klyubin et al., 2005), or how much", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 455, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 505, + 468 + ], + "score": 1.0, + "content": "control the agent has over its environment. Our work is related in the sense that it is in both Alice’s", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 466, + 506, + 479 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 506, + 479 + ], + "score": 1.0, + "content": "and Bob’s interests to have more control over the environment; but we do not explicitly measure that", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 478, + 318, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 318, + 489 + ], + "score": 1.0, + "content": "control except in relation to the tasks that Alice sets.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 107, + 494, + 504, + 550 + ], + "lines": [ + { + "bbox": [ + 105, + 493, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 505, + 507 + ], + "score": 1.0, + "content": "Curriculum learning (Bengio et al., 2009) is widely used in many machine learning approaches.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 505, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 505, + 519 + ], + "score": 1.0, + "content": "Typically however, the curriculum requires at least some manual specification. A key point about", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 516, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 505, + 529 + ], + "score": 1.0, + "content": "our work is that Alice and Bob devise their own curriculum entirely automatically. Previous auto-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 527, + 506, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 506, + 541 + ], + "score": 1.0, + "content": "matic approaches, such as Kumar et al. (2010), rely on monitoring training error. But since ours is", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 538, + 313, + 551 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 313, + 551 + ], + "score": 1.0, + "content": "unsupervised, no training labels are required either.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 555, + 504, + 610 + ], + "lines": [ + { + "bbox": [ + 105, + 554, + 505, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 505, + 567 + ], + "score": 1.0, + "content": "Our basic paradigm of “Alice proposing a task, and Bob doing it” is related to the Horde architecture", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 565, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 505, + 579 + ], + "score": 1.0, + "content": "(Sutton et al., 2011) and (Schaul et al., 2015). In those works, instead of using a value function", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 107, + 576, + 506, + 590 + ], + "spans": [ + { + "bbox": [ + 107, + 577, + 151, + 588 + ], + "score": 0.9, + "content": "V = V ( s )", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 576, + 506, + 590 + ], + "score": 1.0, + "content": "that depends on the current state, a value function that explicitly depends on state and", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 586, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 104, + 586, + 126, + 601 + ], + "score": 1.0, + "content": "goal", + "type": "text" + }, + { + "bbox": [ + 126, + 588, + 178, + 600 + ], + "score": 0.92, + "content": "V = V ( s , g )", + "type": "inline_equation" + }, + { + "bbox": [ + 178, + 586, + 506, + 601 + ], + "score": 1.0, + "content": "is used. In our experiments, our models will be parameterized in a similar fashion.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 599, + 369, + 611 + ], + "spans": [ + { + "bbox": [ + 106, + 599, + 369, + 611 + ], + "score": 1.0, + "content": "The novelty in this work is in how Alice defines the goal for Bob.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 107, + 615, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 615, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 628 + ], + "score": 1.0, + "content": "The closest work to ours is that of Baranes & Oudeyer (2013), who also have one part of the model", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 627, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 505, + 640 + ], + "score": 1.0, + "content": "that proposes tasks, while another part learns to complete them. As in this work, the policies and", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 637, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 651 + ], + "score": 1.0, + "content": "cost are parameterized as functions of both state and goal. However, our approach differs in the way", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 648, + 506, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 506, + 662 + ], + "score": 1.0, + "content": "tasks are proposed and communicated. In particular, in Baranes & Oudeyer (2013), the goal space", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "has to be presented in a way that allows explicit partitioning and sampling, whereas in our work, the", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 671, + 506, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 506, + 684 + ], + "score": 1.0, + "content": "goals are sampled through Alice’s actions. On the other hand, we pay for not having to have such a", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 682, + 426, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 426, + 694 + ], + "score": 1.0, + "content": "representation by requiring the environment to be either reversible or resettable.", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 46 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "Several concurrent works are related: Andrychowicz et al. (2017) form an implicit curriculum by", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 709, + 504, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 504, + 723 + ], + "score": 1.0, + "content": "using internal states as a target. Florensa et al. (2017) automatically generate a series of increasingly", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 106, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "distant start states from a goal. Pinto et al. (2017) use an adversarial framework to perturb the", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 51 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 759 + ], + "lines": [] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 210, + 93 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 213, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 213, + 95 + ], + "score": 1.0, + "content": "3 RELATED WORK", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 125, + 505, + 191 + ], + "lines": [ + { + "bbox": [ + 105, + 126, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 505, + 138 + ], + "score": 1.0, + "content": "Self-play arises naturally in reinforcement learning, and has been well studied. For example, for", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 137, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 505, + 150 + ], + "score": 1.0, + "content": "playing checkers (Samuel, 1959), backgammon (Tesauro, 1995), and Go, (Silver et al., 2016), and", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 147, + 505, + 160 + ], + "spans": [ + { + "bbox": [ + 105, + 147, + 505, + 160 + ], + "score": 1.0, + "content": "in multi-agent games such as RoboSoccer (Riedmiller et al., 2009). Here, the agents or teams", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 159, + 504, + 172 + ], + "spans": [ + { + "bbox": [ + 106, + 159, + 504, + 172 + ], + "score": 1.0, + "content": "of agents compete for external reward. This differs from our scheme where the reward is purely", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 168, + 506, + 183 + ], + "spans": [ + { + "bbox": [ + 105, + 168, + 506, + 183 + ], + "score": 1.0, + "content": "internal and the self-play is a way of motivating an agent to learn about its environment to augment", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 181, + 275, + 193 + ], + "spans": [ + { + "bbox": [ + 105, + 181, + 275, + 193 + ], + "score": 1.0, + "content": "sparse rewards from separate target tasks.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 126, + 506, + 193 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 197, + 505, + 307 + ], + "lines": [ + { + "bbox": [ + 105, + 198, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 505, + 210 + ], + "score": 1.0, + "content": "Our approach has some relationships with generative adversarial networks (GANs) (Goodfellow", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 208, + 505, + 221 + ], + "spans": [ + { + "bbox": [ + 105, + 208, + 505, + 221 + ], + "score": 1.0, + "content": "et al., 2014), which train a generative neural net by having it try to fool a discriminator network", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 219, + 505, + 232 + ], + "spans": [ + { + "bbox": [ + 105, + 219, + 505, + 232 + ], + "score": 1.0, + "content": "which tries to differentiate samples from the training examples. Li et al. (2017) introduce an adver-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 231, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 505, + 243 + ], + "score": 1.0, + "content": "sarial approach to dialogue generation, where a generator model is subjected to a form of “Turing", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 241, + 505, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 505, + 254 + ], + "score": 1.0, + "content": "test” by a discriminator network. Mescheder et al. (2017) demonstrate how adversarial loss terms", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 253, + 505, + 264 + ], + "spans": [ + { + "bbox": [ + 106, + 253, + 505, + 264 + ], + "score": 1.0, + "content": "can be combined with variational auto-encoders to permit more accurate density modeling. While", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "score": 1.0, + "content": "GAN’s are often thought of as methods for training a generator, the generator can be thought of as", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 274, + 505, + 287 + ], + "spans": [ + { + "bbox": [ + 105, + 274, + 505, + 287 + ], + "score": 1.0, + "content": "a method for generating hard negatives for the discriminator. From this viewpoint, in our approach,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 286, + 505, + 297 + ], + "spans": [ + { + "bbox": [ + 106, + 286, + 505, + 297 + ], + "score": 1.0, + "content": "Alice acts as a “generator”, finding “negatives” for Bob. However, Bob’s jobs is to complete the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 296, + 279, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 279, + 308 + ], + "score": 1.0, + "content": "generated challenge, not to discriminate it.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 198, + 505, + 308 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 313, + 505, + 489 + ], + "lines": [ + { + "bbox": [ + 106, + 313, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 106, + 313, + 505, + 326 + ], + "score": 1.0, + "content": "There is a large body of work on intrinsic motivation (Barto, 2013; Singh et al., 2004; Klyubin", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 324, + 505, + 337 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 505, + 337 + ], + "score": 1.0, + "content": "et al., 2005; Schmidhuber, 1991) for self-supervised learning agents. These works propose methods", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 335, + 506, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 506, + 348 + ], + "score": 1.0, + "content": "for training an agent to explore and become proficient at manipulating its environment without", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 347, + 505, + 359 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 505, + 359 + ], + "score": 1.0, + "content": "necessarily having a specific target task, and without a source of extrinsic supervision. One line in", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 357, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 357, + 505, + 369 + ], + "score": 1.0, + "content": "this direction is curiosity-driven exploration (Schmidhuber, 1991). These techniques can be applied", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 367, + 505, + 381 + ], + "spans": [ + { + "bbox": [ + 104, + 367, + 505, + 381 + ], + "score": 1.0, + "content": "in encouraging exploration in the context of reinforcement learning, for example (Bellemare et al.,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 377, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 377, + 505, + 392 + ], + "score": 1.0, + "content": "2016; Strehl & Littman, 2008; Lopes et al., 2012; Tang et al., 2016; Pathak et al., 2017); Roughly,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 390, + 505, + 402 + ], + "spans": [ + { + "bbox": [ + 105, + 390, + 505, + 402 + ], + "score": 1.0, + "content": "these use some notion of the novelty of a state to give a reward. In the simplest setting, novelty can", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 401, + 506, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 506, + 413 + ], + "score": 1.0, + "content": "be just the number of times a state has been visited; in more complex scenarios, the agent can build", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 412, + 506, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 506, + 424 + ], + "score": 1.0, + "content": "a model of the world, and the novelty is the difficulty in placing the current state into the model. In", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 423, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 505, + 434 + ], + "score": 1.0, + "content": "our work, there is no explicit notion of novelty. Even if Bob has seen a state many times, if he has", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 433, + 506, + 446 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 506, + 446 + ], + "score": 1.0, + "content": "trouble getting to it, Alice should force him towards that state. Another line of work on intrinsic", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 445, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 505, + 456 + ], + "score": 1.0, + "content": "motivation is a formalization of the notion of empowerment (Klyubin et al., 2005), or how much", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 455, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 505, + 468 + ], + "score": 1.0, + "content": "control the agent has over its environment. Our work is related in the sense that it is in both Alice’s", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 466, + 506, + 479 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 506, + 479 + ], + "score": 1.0, + "content": "and Bob’s interests to have more control over the environment; but we do not explicitly measure that", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 478, + 318, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 318, + 489 + ], + "score": 1.0, + "content": "control except in relation to the tasks that Alice sets.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 24.5, + "bbox_fs": [ + 104, + 313, + 506, + 489 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 494, + 504, + 550 + ], + "lines": [ + { + "bbox": [ + 105, + 493, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 505, + 507 + ], + "score": 1.0, + "content": "Curriculum learning (Bengio et al., 2009) is widely used in many machine learning approaches.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 505, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 505, + 519 + ], + "score": 1.0, + "content": "Typically however, the curriculum requires at least some manual specification. A key point about", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 516, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 505, + 529 + ], + "score": 1.0, + "content": "our work is that Alice and Bob devise their own curriculum entirely automatically. Previous auto-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 527, + 506, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 506, + 541 + ], + "score": 1.0, + "content": "matic approaches, such as Kumar et al. (2010), rely on monitoring training error. But since ours is", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 538, + 313, + 551 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 313, + 551 + ], + "score": 1.0, + "content": "unsupervised, no training labels are required either.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 493, + 506, + 551 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 555, + 504, + 610 + ], + "lines": [ + { + "bbox": [ + 105, + 554, + 505, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 505, + 567 + ], + "score": 1.0, + "content": "Our basic paradigm of “Alice proposing a task, and Bob doing it” is related to the Horde architecture", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 565, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 505, + 579 + ], + "score": 1.0, + "content": "(Sutton et al., 2011) and (Schaul et al., 2015). In those works, instead of using a value function", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 107, + 576, + 506, + 590 + ], + "spans": [ + { + "bbox": [ + 107, + 577, + 151, + 588 + ], + "score": 0.9, + "content": "V = V ( s )", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 576, + 506, + 590 + ], + "score": 1.0, + "content": "that depends on the current state, a value function that explicitly depends on state and", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 586, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 104, + 586, + 126, + 601 + ], + "score": 1.0, + "content": "goal", + "type": "text" + }, + { + "bbox": [ + 126, + 588, + 178, + 600 + ], + "score": 0.92, + "content": "V = V ( s , g )", + "type": "inline_equation" + }, + { + "bbox": [ + 178, + 586, + 506, + 601 + ], + "score": 1.0, + "content": "is used. In our experiments, our models will be parameterized in a similar fashion.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 599, + 369, + 611 + ], + "spans": [ + { + "bbox": [ + 106, + 599, + 369, + 611 + ], + "score": 1.0, + "content": "The novelty in this work is in how Alice defines the goal for Bob.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40, + "bbox_fs": [ + 104, + 554, + 506, + 611 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 615, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 615, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 628 + ], + "score": 1.0, + "content": "The closest work to ours is that of Baranes & Oudeyer (2013), who also have one part of the model", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 627, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 505, + 640 + ], + "score": 1.0, + "content": "that proposes tasks, while another part learns to complete them. As in this work, the policies and", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 637, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 651 + ], + "score": 1.0, + "content": "cost are parameterized as functions of both state and goal. However, our approach differs in the way", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 648, + 506, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 506, + 662 + ], + "score": 1.0, + "content": "tasks are proposed and communicated. In particular, in Baranes & Oudeyer (2013), the goal space", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "has to be presented in a way that allows explicit partitioning and sampling, whereas in our work, the", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 671, + 506, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 506, + 684 + ], + "score": 1.0, + "content": "goals are sampled through Alice’s actions. On the other hand, we pay for not having to have such a", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 682, + 426, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 426, + 694 + ], + "score": 1.0, + "content": "representation by requiring the environment to be either reversible or resettable.", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 46, + "bbox_fs": [ + 105, + 615, + 506, + 694 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "Several concurrent works are related: Andrychowicz et al. (2017) form an implicit curriculum by", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 709, + 504, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 504, + 723 + ], + "score": 1.0, + "content": "using internal states as a target. Florensa et al. (2017) automatically generate a series of increasingly", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 106, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "distant start states from a goal. Pinto et al. (2017) use an adversarial framework to perturb the", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "environment, inducing improved robustness of the agent. Held et al. (2017) propose a scheme", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 268, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 268, + 106 + ], + "score": 1.0, + "content": "related to our “random Alice” strategy2.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + } + ], + "index": 51, + "bbox_fs": [ + 105, + 698, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "environment, inducing improved robustness of the agent. Held et al. (2017) propose a scheme", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 268, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 268, + 106 + ], + "score": 1.0, + "content": "related to our “random Alice” strategy2.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "title", + "bbox": [ + 108, + 116, + 201, + 128 + ], + "lines": [ + { + "bbox": [ + 105, + 115, + 201, + 130 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 201, + 130 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 106, + 134, + 505, + 234 + ], + "lines": [ + { + "bbox": [ + 105, + 133, + 506, + 147 + ], + "spans": [ + { + "bbox": [ + 105, + 133, + 506, + 147 + ], + "score": 1.0, + "content": "The following experiments explore our self-play approach on a variety of tasks, both continuous", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 145, + 505, + 158 + ], + "spans": [ + { + "bbox": [ + 105, + 145, + 505, + 158 + ], + "score": 1.0, + "content": "and discrete, from the Mazebase (Sukhbaatar et al., 2015), RLLab (Duan et al., 2016), and Star-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 156, + 506, + 169 + ], + "spans": [ + { + "bbox": [ + 106, + 156, + 506, + 169 + ], + "score": 1.0, + "content": "Craft (Synnaeve et al., 2016) environments. The same protocol is used in all settings: self-play and", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 167, + 506, + 180 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 506, + 180 + ], + "score": 1.0, + "content": "target task episodes are mixed together and used to train the agent via discrete policy gradient. We", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 178, + 505, + 191 + ], + "spans": [ + { + "bbox": [ + 105, + 178, + 505, + 191 + ], + "score": 1.0, + "content": "evaluate both the reverse and repeat versions of self-play. We demonstrate that the self-play episodes", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 189, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 105, + 189, + 505, + 203 + ], + "score": 1.0, + "content": "help training, in terms of number of target task episodes needed to learn the task. Note that we as-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 201, + 505, + 212 + ], + "spans": [ + { + "bbox": [ + 106, + 201, + 505, + 212 + ], + "score": 1.0, + "content": "sume the self-play episodes to be “free”, since they make no use of environmental reward. This is", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 210, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 505, + 225 + ], + "score": 1.0, + "content": "consistent with traditional semi-supervised learning, where evaluations typically are based only on", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 223, + 324, + 235 + ], + "spans": [ + { + "bbox": [ + 106, + 223, + 324, + 235 + ], + "score": 1.0, + "content": "the number of labeled points (not unlabeled ones too).", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 106, + 238, + 505, + 327 + ], + "lines": [ + { + "bbox": [ + 105, + 239, + 506, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 506, + 252 + ], + "score": 1.0, + "content": "In all the experiments we use policy gradient (Williams, 1992) with a baseline for optimizing the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 250, + 505, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 505, + 263 + ], + "score": 1.0, + "content": "policies. In the tabular task below, we use a constant baseline; in all the other tasks we use a policy", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 261, + 506, + 273 + ], + "spans": [ + { + "bbox": [ + 104, + 261, + 506, + 273 + ], + "score": 1.0, + "content": "parameterized by a neural network, and a baseline that depends on the state. We denote the states in", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 272, + 506, + 285 + ], + "spans": [ + { + "bbox": [ + 104, + 272, + 165, + 285 + ], + "score": 1.0, + "content": "an episode by", + "type": "text" + }, + { + "bbox": [ + 165, + 273, + 203, + 283 + ], + "score": 0.9, + "content": "s _ { 1 } , . . . , s _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 204, + 272, + 399, + 285 + ], + "score": 1.0, + "content": ", and the actions taken at each of those states as", + "type": "text" + }, + { + "bbox": [ + 399, + 273, + 439, + 284 + ], + "score": 0.89, + "content": "a _ { 1 } , . . . , a _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 439, + 272, + 470, + 285 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 470, + 272, + 479, + 282 + ], + "score": 0.82, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 272, + 506, + 285 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 381, + 295 + ], + "score": 1.0, + "content": "length of the episode. The baseline is a scalar function of the states", + "type": "text" + }, + { + "bbox": [ + 382, + 283, + 408, + 295 + ], + "score": 0.93, + "content": "b ( s , \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 282, + 505, + 295 + ], + "score": 1.0, + "content": ", computed via an extra", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 294, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 505, + 306 + ], + "score": 1.0, + "content": "head on the network producing the action probabilities. Besides maximizing the expected reward", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 305, + 505, + 317 + ], + "spans": [ + { + "bbox": [ + 106, + 305, + 505, + 317 + ], + "score": 1.0, + "content": "with policy gradient, the models are also trained to minimize the distance between the baseline value", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 316, + 461, + 328 + ], + "spans": [ + { + "bbox": [ + 105, + 316, + 442, + 328 + ], + "score": 1.0, + "content": "and actual reward. Thus after finishing an episode, we update the model parameters", + "type": "text" + }, + { + "bbox": [ + 442, + 316, + 448, + 326 + ], + "score": 0.81, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 316, + 461, + 328 + ], + "score": 1.0, + "content": "by", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 15.5 + }, + { + "type": "interline_equation", + "bbox": [ + 140, + 333, + 470, + 370 + ], + "lines": [ + { + "bbox": [ + 140, + 333, + 470, + 370 + ], + "spans": [ + { + "bbox": [ + 140, + 333, + 470, + 370 + ], + "score": 0.92, + "content": "\\Delta \\theta = \\sum _ { t = 1 } ^ { T } \\left[ \\frac { \\partial \\log f ( a _ { t } | s _ { t } , \\theta ) } { \\partial \\theta } \\left( \\sum _ { i = t } ^ { T } r _ { i } - b ( s _ { t } , \\theta ) \\right) - \\lambda \\frac { \\partial } { \\partial \\theta } \\left( \\sum _ { i = t } ^ { T } r _ { i } - b ( s _ { t } , \\theta ) \\right) ^ { 2 } \\right] .", + "type": "interline_equation", + "image_path": "dc6c9ad6cdeeb4d42a115f900e96f4619d7b1a30299f3fb6795ec735a5a54e25.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 140, + 333, + 470, + 345.3333333333333 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 140, + 345.3333333333333, + 470, + 357.66666666666663 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 140, + 357.66666666666663, + 470, + 369.99999999999994 + ], + "spans": [], + "index": 22 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 376, + 505, + 398 + ], + "lines": [ + { + "bbox": [ + 106, + 375, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 375, + 129, + 388 + ], + "score": 1.0, + "content": "Here", + "type": "text" + }, + { + "bbox": [ + 129, + 378, + 139, + 387 + ], + "score": 0.84, + "content": "r _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 375, + 239, + 388 + ], + "score": 1.0, + "content": "is reward given at time", + "type": "text" + }, + { + "bbox": [ + 239, + 377, + 244, + 386 + ], + "score": 0.71, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 375, + 348, + 388 + ], + "score": 1.0, + "content": ", and the hyperparameter", + "type": "text" + }, + { + "bbox": [ + 349, + 376, + 356, + 386 + ], + "score": 0.81, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 375, + 505, + 388 + ], + "score": 1.0, + "content": "is for balancing the reward and the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 386, + 338, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 338, + 399 + ], + "score": 1.0, + "content": "baseline objectives, which is set to 0.1 in all experiments.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 107, + 403, + 505, + 448 + ], + "lines": [ + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "score": 1.0, + "content": "For the policy neural networks, we use two-layer fully-connected networks with 50 hidden units in", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 414, + 505, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 505, + 427 + ], + "score": 1.0, + "content": "each layer. The training uses RMSProp (Tieleman & Hinton, 2012). We always do 10 runs with", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 425, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 481, + 439 + ], + "score": 1.0, + "content": "different random initializations and report their mean and standard deviation. See Appendix", + "type": "text" + }, + { + "bbox": [ + 481, + 426, + 489, + 435 + ], + "score": 0.26, + "content": "\\mathbf { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 489, + 425, + 505, + 439 + ], + "score": 1.0, + "content": "for", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 437, + 326, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 326, + 448 + ], + "score": 1.0, + "content": "all the hyperparameter values used in the experiments.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5 + }, + { + "type": "title", + "bbox": [ + 107, + 456, + 200, + 467 + ], + "lines": [ + { + "bbox": [ + 105, + 454, + 203, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 203, + 469 + ], + "score": 1.0, + "content": "4.1 LONG HALLWAY", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 476, + 505, + 564 + ], + "lines": [ + { + "bbox": [ + 106, + 476, + 504, + 488 + ], + "spans": [ + { + "bbox": [ + 106, + 476, + 504, + 488 + ], + "score": 1.0, + "content": "We first describe a simple toy environment designed to illustrate the function of the asymmetric self-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 486, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 246, + 500 + ], + "score": 1.0, + "content": "play. The environment consists of", + "type": "text" + }, + { + "bbox": [ + 247, + 487, + 259, + 497 + ], + "score": 0.81, + "content": "M", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 486, + 285, + 500 + ], + "score": 1.0, + "content": "states", + "type": "text" + }, + { + "bbox": [ + 286, + 487, + 336, + 499 + ], + "score": 0.93, + "content": "\\{ \\bar { s _ { 1 } } , . . . , s _ { M } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 486, + 505, + 500 + ], + "score": 1.0, + "content": "arranged in a chain. Both Alice and Bob", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 498, + 505, + 511 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 383, + 511 + ], + "score": 1.0, + "content": "have three possible actions, “left”, “right”, or “stop”. If the agent is at", + "type": "text" + }, + { + "bbox": [ + 383, + 500, + 393, + 509 + ], + "score": 0.85, + "content": "s _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 498, + 413, + 511 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 414, + 498, + 436, + 510 + ], + "score": 0.9, + "content": "i \\neq 1", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 498, + 505, + 511 + ], + "score": 1.0, + "content": ", “left” takes it to", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 509, + 506, + 522 + ], + "spans": [ + { + "bbox": [ + 106, + 510, + 126, + 521 + ], + "score": 0.87, + "content": "s _ { i - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 126, + 509, + 506, + 522 + ], + "score": 1.0, + "content": "; “right” analogously increases the state index, and “stop” transfers control to Bob when Alice", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 519, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 104, + 519, + 505, + 533 + ], + "score": 1.0, + "content": "runs it and terminates the episode when Bob runs it. We use “return to initial state” as the self-play", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 529, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 104, + 529, + 505, + 545 + ], + "score": 1.0, + "content": "task (i.e. Reverse in Algorithm 1 in Appendix A ). For the target task, we randomly pick a starting", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 542, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 505, + 554 + ], + "score": 1.0, + "content": "state and target state, and the episode is considered successful if Bob moves to the target state and", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 552, + 373, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 373, + 567 + ], + "score": 1.0, + "content": "executes the stop action before a fixed number of maximum steps.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 33.5 + }, + { + "type": "text", + "bbox": [ + 107, + 570, + 505, + 626 + ], + "lines": [ + { + "bbox": [ + 105, + 569, + 505, + 582 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 505, + 582 + ], + "score": 1.0, + "content": "In this case, the target task is essentially the same as the self-play task, and so running it is not", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 581, + 506, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 506, + 594 + ], + "score": 1.0, + "content": "unsupervised learning (and in particular, on this toy example unlike the other examples below, we", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 591, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 505, + 605 + ], + "score": 1.0, + "content": "do not mix self-play training with target task training). However, we see that the curriculum afforded", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 600, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 506, + 617 + ], + "score": 1.0, + "content": "by the self-play is efficient at training the agent to do the target task at the beginning of the training,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 613, + 445, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 445, + 627 + ], + "score": 1.0, + "content": "and is effective at forcing exploration of the state space as Bob gets more competent.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 106, + 630, + 505, + 675 + ], + "lines": [ + { + "bbox": [ + 106, + 631, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 106, + 631, + 505, + 642 + ], + "score": 1.0, + "content": "In Fig. 2 (left) we plot the number of episodes vs rate of success at the target task with four different", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 641, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 174, + 653 + ], + "score": 1.0, + "content": "methods. We set", + "type": "text" + }, + { + "bbox": [ + 175, + 642, + 210, + 652 + ], + "score": 0.9, + "content": "M = 2 5", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 641, + 505, + 653 + ], + "score": 1.0, + "content": "and the maximum allowed steps for Alice and Bob to be 30. We use fully", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 652, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 263, + 664 + ], + "score": 1.0, + "content": "tabular controllers; the table is of size", + "type": "text" + }, + { + "bbox": [ + 263, + 652, + 298, + 663 + ], + "score": 0.92, + "content": "M ^ { 2 } \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 653, + 505, + 664 + ], + "score": 1.0, + "content": ", with a distribution over the three actions for each", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 664, + 207, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 207, + 676 + ], + "score": 1.0, + "content": "possible (start, end pair).", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 44.5 + }, + { + "type": "text", + "bbox": [ + 108, + 680, + 503, + 703 + ], + "lines": [ + { + "bbox": [ + 106, + 679, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 106, + 679, + 364, + 694 + ], + "score": 1.0, + "content": "The red curve corresponds to policy gradient, with a penalty of", + "type": "text" + }, + { + "bbox": [ + 364, + 681, + 378, + 691 + ], + "score": 0.69, + "content": "- 1", + "type": "inline_equation" + }, + { + "bbox": [ + 378, + 679, + 505, + 694 + ], + "score": 1.0, + "content": "given upon failure to complete", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 691, + 505, + 705 + ], + "spans": [ + { + "bbox": [ + 106, + 691, + 207, + 705 + ], + "score": 1.0, + "content": "the task, and a penalty of", + "type": "text" + }, + { + "bbox": [ + 207, + 692, + 241, + 704 + ], + "score": 0.92, + "content": "- t / t _ { \\mathrm { M a x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 691, + 396, + 705 + ], + "score": 1.0, + "content": "for successfully completing the task in", + "type": "text" + }, + { + "bbox": [ + 396, + 693, + 401, + 702 + ], + "score": 0.74, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 691, + 505, + 705 + ], + "score": 1.0, + "content": "steps. The magenta curve", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47.5 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 711, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 118, + 709, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 118, + 709, + 506, + 724 + ], + "score": 1.0, + "content": "2In their paper they analyzed our approach, suggesting it was inherently unstable. However, the analysis", + "type": "text" + } + ] + }, + { + "bbox": [ + 105, + 720, + 474, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 474, + 733 + ], + "score": 1.0, + "content": "relied on a sudden jump of Bob policy with respect to Alice’s, which is unlikely to happen in practice.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published 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": [ + 106, + 82, + 504, + 105 + ], + "lines": [], + "index": 0.5, + "bbox_fs": [ + 105, + 82, + 505, + 106 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 108, + 116, + 201, + 128 + ], + "lines": [ + { + "bbox": [ + 105, + 115, + 201, + 130 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 201, + 130 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 106, + 134, + 505, + 234 + ], + "lines": [ + { + "bbox": [ + 105, + 133, + 506, + 147 + ], + "spans": [ + { + "bbox": [ + 105, + 133, + 506, + 147 + ], + "score": 1.0, + "content": "The following experiments explore our self-play approach on a variety of tasks, both continuous", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 145, + 505, + 158 + ], + "spans": [ + { + "bbox": [ + 105, + 145, + 505, + 158 + ], + "score": 1.0, + "content": "and discrete, from the Mazebase (Sukhbaatar et al., 2015), RLLab (Duan et al., 2016), and Star-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 156, + 506, + 169 + ], + "spans": [ + { + "bbox": [ + 106, + 156, + 506, + 169 + ], + "score": 1.0, + "content": "Craft (Synnaeve et al., 2016) environments. The same protocol is used in all settings: self-play and", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 167, + 506, + 180 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 506, + 180 + ], + "score": 1.0, + "content": "target task episodes are mixed together and used to train the agent via discrete policy gradient. We", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 178, + 505, + 191 + ], + "spans": [ + { + "bbox": [ + 105, + 178, + 505, + 191 + ], + "score": 1.0, + "content": "evaluate both the reverse and repeat versions of self-play. We demonstrate that the self-play episodes", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 189, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 105, + 189, + 505, + 203 + ], + "score": 1.0, + "content": "help training, in terms of number of target task episodes needed to learn the task. Note that we as-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 201, + 505, + 212 + ], + "spans": [ + { + "bbox": [ + 106, + 201, + 505, + 212 + ], + "score": 1.0, + "content": "sume the self-play episodes to be “free”, since they make no use of environmental reward. This is", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 210, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 505, + 225 + ], + "score": 1.0, + "content": "consistent with traditional semi-supervised learning, where evaluations typically are based only on", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 223, + 324, + 235 + ], + "spans": [ + { + "bbox": [ + 106, + 223, + 324, + 235 + ], + "score": 1.0, + "content": "the number of labeled points (not unlabeled ones too).", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 7, + "bbox_fs": [ + 105, + 133, + 506, + 235 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 238, + 505, + 327 + ], + "lines": [ + { + "bbox": [ + 105, + 239, + 506, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 506, + 252 + ], + "score": 1.0, + "content": "In all the experiments we use policy gradient (Williams, 1992) with a baseline for optimizing the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 250, + 505, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 505, + 263 + ], + "score": 1.0, + "content": "policies. In the tabular task below, we use a constant baseline; in all the other tasks we use a policy", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 261, + 506, + 273 + ], + "spans": [ + { + "bbox": [ + 104, + 261, + 506, + 273 + ], + "score": 1.0, + "content": "parameterized by a neural network, and a baseline that depends on the state. We denote the states in", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 272, + 506, + 285 + ], + "spans": [ + { + "bbox": [ + 104, + 272, + 165, + 285 + ], + "score": 1.0, + "content": "an episode by", + "type": "text" + }, + { + "bbox": [ + 165, + 273, + 203, + 283 + ], + "score": 0.9, + "content": "s _ { 1 } , . . . , s _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 204, + 272, + 399, + 285 + ], + "score": 1.0, + "content": ", and the actions taken at each of those states as", + "type": "text" + }, + { + "bbox": [ + 399, + 273, + 439, + 284 + ], + "score": 0.89, + "content": "a _ { 1 } , . . . , a _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 439, + 272, + 470, + 285 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 470, + 272, + 479, + 282 + ], + "score": 0.82, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 272, + 506, + 285 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 381, + 295 + ], + "score": 1.0, + "content": "length of the episode. The baseline is a scalar function of the states", + "type": "text" + }, + { + "bbox": [ + 382, + 283, + 408, + 295 + ], + "score": 0.93, + "content": "b ( s , \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 282, + 505, + 295 + ], + "score": 1.0, + "content": ", computed via an extra", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 294, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 505, + 306 + ], + "score": 1.0, + "content": "head on the network producing the action probabilities. Besides maximizing the expected reward", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 305, + 505, + 317 + ], + "spans": [ + { + "bbox": [ + 106, + 305, + 505, + 317 + ], + "score": 1.0, + "content": "with policy gradient, the models are also trained to minimize the distance between the baseline value", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 316, + 461, + 328 + ], + "spans": [ + { + "bbox": [ + 105, + 316, + 442, + 328 + ], + "score": 1.0, + "content": "and actual reward. Thus after finishing an episode, we update the model parameters", + "type": "text" + }, + { + "bbox": [ + 442, + 316, + 448, + 326 + ], + "score": 0.81, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 316, + 461, + 328 + ], + "score": 1.0, + "content": "by", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 15.5, + "bbox_fs": [ + 104, + 239, + 506, + 328 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 140, + 333, + 470, + 370 + ], + "lines": [ + { + "bbox": [ + 140, + 333, + 470, + 370 + ], + "spans": [ + { + "bbox": [ + 140, + 333, + 470, + 370 + ], + "score": 0.92, + "content": "\\Delta \\theta = \\sum _ { t = 1 } ^ { T } \\left[ \\frac { \\partial \\log f ( a _ { t } | s _ { t } , \\theta ) } { \\partial \\theta } \\left( \\sum _ { i = t } ^ { T } r _ { i } - b ( s _ { t } , \\theta ) \\right) - \\lambda \\frac { \\partial } { \\partial \\theta } \\left( \\sum _ { i = t } ^ { T } r _ { i } - b ( s _ { t } , \\theta ) \\right) ^ { 2 } \\right] .", + "type": "interline_equation", + "image_path": "dc6c9ad6cdeeb4d42a115f900e96f4619d7b1a30299f3fb6795ec735a5a54e25.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 140, + 333, + 470, + 345.3333333333333 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 140, + 345.3333333333333, + 470, + 357.66666666666663 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 140, + 357.66666666666663, + 470, + 369.99999999999994 + ], + "spans": [], + "index": 22 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 376, + 505, + 398 + ], + "lines": [ + { + "bbox": [ + 106, + 375, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 375, + 129, + 388 + ], + "score": 1.0, + "content": "Here", + "type": "text" + }, + { + "bbox": [ + 129, + 378, + 139, + 387 + ], + "score": 0.84, + "content": "r _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 375, + 239, + 388 + ], + "score": 1.0, + "content": "is reward given at time", + "type": "text" + }, + { + "bbox": [ + 239, + 377, + 244, + 386 + ], + "score": 0.71, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 375, + 348, + 388 + ], + "score": 1.0, + "content": ", and the hyperparameter", + "type": "text" + }, + { + "bbox": [ + 349, + 376, + 356, + 386 + ], + "score": 0.81, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 375, + 505, + 388 + ], + "score": 1.0, + "content": "is for balancing the reward and the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 386, + 338, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 338, + 399 + ], + "score": 1.0, + "content": "baseline objectives, which is set to 0.1 in all experiments.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 375, + 505, + 399 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 403, + 505, + 448 + ], + "lines": [ + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "score": 1.0, + "content": "For the policy neural networks, we use two-layer fully-connected networks with 50 hidden units in", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 414, + 505, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 505, + 427 + ], + "score": 1.0, + "content": "each layer. The training uses RMSProp (Tieleman & Hinton, 2012). We always do 10 runs with", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 425, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 481, + 439 + ], + "score": 1.0, + "content": "different random initializations and report their mean and standard deviation. See Appendix", + "type": "text" + }, + { + "bbox": [ + 481, + 426, + 489, + 435 + ], + "score": 0.26, + "content": "\\mathbf { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 489, + 425, + 505, + 439 + ], + "score": 1.0, + "content": "for", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 437, + 326, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 326, + 448 + ], + "score": 1.0, + "content": "all the hyperparameter values used in the experiments.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 404, + 505, + 448 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 456, + 200, + 467 + ], + "lines": [ + { + "bbox": [ + 105, + 454, + 203, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 203, + 469 + ], + "score": 1.0, + "content": "4.1 LONG HALLWAY", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 476, + 505, + 564 + ], + "lines": [ + { + "bbox": [ + 106, + 476, + 504, + 488 + ], + "spans": [ + { + "bbox": [ + 106, + 476, + 504, + 488 + ], + "score": 1.0, + "content": "We first describe a simple toy environment designed to illustrate the function of the asymmetric self-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 486, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 246, + 500 + ], + "score": 1.0, + "content": "play. The environment consists of", + "type": "text" + }, + { + "bbox": [ + 247, + 487, + 259, + 497 + ], + "score": 0.81, + "content": "M", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 486, + 285, + 500 + ], + "score": 1.0, + "content": "states", + "type": "text" + }, + { + "bbox": [ + 286, + 487, + 336, + 499 + ], + "score": 0.93, + "content": "\\{ \\bar { s _ { 1 } } , . . . , s _ { M } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 486, + 505, + 500 + ], + "score": 1.0, + "content": "arranged in a chain. Both Alice and Bob", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 498, + 505, + 511 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 383, + 511 + ], + "score": 1.0, + "content": "have three possible actions, “left”, “right”, or “stop”. If the agent is at", + "type": "text" + }, + { + "bbox": [ + 383, + 500, + 393, + 509 + ], + "score": 0.85, + "content": "s _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 498, + 413, + 511 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 414, + 498, + 436, + 510 + ], + "score": 0.9, + "content": "i \\neq 1", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 498, + 505, + 511 + ], + "score": 1.0, + "content": ", “left” takes it to", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 509, + 506, + 522 + ], + "spans": [ + { + "bbox": [ + 106, + 510, + 126, + 521 + ], + "score": 0.87, + "content": "s _ { i - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 126, + 509, + 506, + 522 + ], + "score": 1.0, + "content": "; “right” analogously increases the state index, and “stop” transfers control to Bob when Alice", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 519, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 104, + 519, + 505, + 533 + ], + "score": 1.0, + "content": "runs it and terminates the episode when Bob runs it. We use “return to initial state” as the self-play", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 529, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 104, + 529, + 505, + 545 + ], + "score": 1.0, + "content": "task (i.e. Reverse in Algorithm 1 in Appendix A ). For the target task, we randomly pick a starting", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 542, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 505, + 554 + ], + "score": 1.0, + "content": "state and target state, and the episode is considered successful if Bob moves to the target state and", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 552, + 373, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 373, + 567 + ], + "score": 1.0, + "content": "executes the stop action before a fixed number of maximum steps.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 33.5, + "bbox_fs": [ + 104, + 476, + 506, + 567 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 570, + 505, + 626 + ], + "lines": [ + { + "bbox": [ + 105, + 569, + 505, + 582 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 505, + 582 + ], + "score": 1.0, + "content": "In this case, the target task is essentially the same as the self-play task, and so running it is not", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 581, + 506, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 506, + 594 + ], + "score": 1.0, + "content": "unsupervised learning (and in particular, on this toy example unlike the other examples below, we", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 591, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 505, + 605 + ], + "score": 1.0, + "content": "do not mix self-play training with target task training). However, we see that the curriculum afforded", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 600, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 506, + 617 + ], + "score": 1.0, + "content": "by the self-play is efficient at training the agent to do the target task at the beginning of the training,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 613, + 445, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 445, + 627 + ], + "score": 1.0, + "content": "and is effective at forcing exploration of the state space as Bob gets more competent.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40, + "bbox_fs": [ + 105, + 569, + 506, + 627 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 630, + 505, + 675 + ], + "lines": [ + { + "bbox": [ + 106, + 631, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 106, + 631, + 505, + 642 + ], + "score": 1.0, + "content": "In Fig. 2 (left) we plot the number of episodes vs rate of success at the target task with four different", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 641, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 174, + 653 + ], + "score": 1.0, + "content": "methods. We set", + "type": "text" + }, + { + "bbox": [ + 175, + 642, + 210, + 652 + ], + "score": 0.9, + "content": "M = 2 5", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 641, + 505, + 653 + ], + "score": 1.0, + "content": "and the maximum allowed steps for Alice and Bob to be 30. We use fully", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 652, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 263, + 664 + ], + "score": 1.0, + "content": "tabular controllers; the table is of size", + "type": "text" + }, + { + "bbox": [ + 263, + 652, + 298, + 663 + ], + "score": 0.92, + "content": "M ^ { 2 } \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 653, + 505, + 664 + ], + "score": 1.0, + "content": ", with a distribution over the three actions for each", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 664, + 207, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 207, + 676 + ], + "score": 1.0, + "content": "possible (start, end pair).", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 44.5, + "bbox_fs": [ + 105, + 631, + 505, + 676 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 680, + 503, + 703 + ], + "lines": [ + { + "bbox": [ + 106, + 679, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 106, + 679, + 364, + 694 + ], + "score": 1.0, + "content": "The red curve corresponds to policy gradient, with a penalty of", + "type": "text" + }, + { + "bbox": [ + 364, + 681, + 378, + 691 + ], + "score": 0.69, + "content": "- 1", + "type": "inline_equation" + }, + { + "bbox": [ + 378, + 679, + 505, + 694 + ], + "score": 1.0, + "content": "given upon failure to complete", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 691, + 505, + 705 + ], + "spans": [ + { + "bbox": [ + 106, + 691, + 207, + 705 + ], + "score": 1.0, + "content": "the task, and a penalty of", + "type": "text" + }, + { + "bbox": [ + 207, + 692, + 241, + 704 + ], + "score": 0.92, + "content": "- t / t _ { \\mathrm { M a x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 691, + 396, + 705 + ], + "score": 1.0, + "content": "for successfully completing the task in", + "type": "text" + }, + { + "bbox": [ + 396, + 693, + 401, + 702 + ], + "score": 0.74, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 691, + 505, + 705 + ], + "score": 1.0, + "content": "steps. The magenta curve", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 82, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 315, + 96 + ], + "score": 1.0, + "content": "corresponds to taking Alice to have a random policy", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 316, + 83, + 334, + 95 + ], + "score": 0.59, + "content": "( 1 / 2", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 334, + 82, + 506, + 96 + ], + "score": 1.0, + "content": "probability of moving left or right, and not", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "stopping till the maximum allowed steps). The green curve corresponds to policy gradient with an", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "exploration bonus similar to Strehl & Littman (2008). That is, we keep count of the number of times√", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 107, + 113, + 505, + 130 + ], + "spans": [ + { + "bbox": [ + 107, + 116, + 120, + 127 + ], + "score": 0.88, + "content": "N _ { s }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 120, + 113, + 247, + 130 + ], + "score": 1.0, + "content": "the agent has been in each state", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 247, + 118, + 253, + 125 + ], + "score": 0.66, + "content": "s", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 253, + 113, + 331, + 130 + ], + "score": 1.0, + "content": ", and the reward for", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 331, + 117, + 337, + 125 + ], + "score": 0.78, + "content": "s", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 338, + 113, + 468, + 130 + ], + "score": 1.0, + "content": "is adjusted by exploration bonus", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 468, + 115, + 501, + 127 + ], + "score": 0.93, + "content": "\\alpha / \\sqrt { N _ { s } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 501, + 113, + 505, + 130 + ], + "score": 1.0, + "content": ",", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 134, + 139 + ], + "score": 1.0, + "content": "where", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 134, + 128, + 142, + 136 + ], + "score": 0.76, + "content": "\\alpha", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 142, + 126, + 505, + 139 + ], + "score": 1.0, + "content": "is a constant balancing the reward from completing the task with the exploration bonus.", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 505, + 151 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 196, + 151 + ], + "score": 1.0, + "content": "We choose the weight", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 196, + 139, + 204, + 147 + ], + "score": 0.77, + "content": "\\alpha", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 205, + 137, + 299, + 151 + ], + "score": 1.0, + "content": "to maximize success at", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 299, + 137, + 322, + 148 + ], + "score": 0.3, + "content": "\\phantom { - } 0 . 2 \\mathbf { M }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 323, + 137, + 410, + 151 + ], + "score": 1.0, + "content": "episodes from the set", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 411, + 137, + 483, + 149 + ], + "score": 0.92, + "content": "\\{ 0 , 0 . 1 , 0 . 2 , . . . , 1 \\}", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 483, + 137, + 505, + 151 + ], + "score": 1.0, + "content": ". The", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 148, + 348, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 348, + 162 + ], + "score": 1.0, + "content": "blue curve corresponds to the asymmetric self-play training.", + "type": "text", + "cross_page": true + } + ], + "index": 6 + } + ], + "index": 47.5, + "bbox_fs": [ + 106, + 679, + 505, + 705 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 160 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 315, + 96 + ], + "score": 1.0, + "content": "corresponds to taking Alice to have a random policy", + "type": "text" + }, + { + "bbox": [ + 316, + 83, + 334, + 95 + ], + "score": 0.59, + "content": "( 1 / 2", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 82, + 506, + 96 + ], + "score": 1.0, + "content": "probability of moving left or right, and not", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "stopping till the maximum allowed steps). The green curve corresponds to policy gradient with an", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "exploration bonus similar to Strehl & Littman (2008). That is, we keep count of the number of times√", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 107, + 113, + 505, + 130 + ], + "spans": [ + { + "bbox": [ + 107, + 116, + 120, + 127 + ], + "score": 0.88, + "content": "N _ { s }", + "type": "inline_equation" + }, + { + "bbox": [ + 120, + 113, + 247, + 130 + ], + "score": 1.0, + "content": "the agent has been in each state", + "type": "text" + }, + { + "bbox": [ + 247, + 118, + 253, + 125 + ], + "score": 0.66, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 113, + 331, + 130 + ], + "score": 1.0, + "content": ", and the reward for", + "type": "text" + }, + { + "bbox": [ + 331, + 117, + 337, + 125 + ], + "score": 0.78, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 113, + 468, + 130 + ], + "score": 1.0, + "content": "is adjusted by exploration bonus", + "type": "text" + }, + { + "bbox": [ + 468, + 115, + 501, + 127 + ], + "score": 0.93, + "content": "\\alpha / \\sqrt { N _ { s } }", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 113, + 505, + 130 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 134, + 139 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 128, + 142, + 136 + ], + "score": 0.76, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 126, + 505, + 139 + ], + "score": 1.0, + "content": "is a constant balancing the reward from completing the task with the exploration bonus.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 505, + 151 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 196, + 151 + ], + "score": 1.0, + "content": "We choose the weight", + "type": "text" + }, + { + "bbox": [ + 196, + 139, + 204, + 147 + ], + "score": 0.77, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 137, + 299, + 151 + ], + "score": 1.0, + "content": "to maximize success at", + "type": "text" + }, + { + "bbox": [ + 299, + 137, + 322, + 148 + ], + "score": 0.3, + "content": "\\phantom { - } 0 . 2 \\mathbf { M }", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 137, + 410, + 151 + ], + "score": 1.0, + "content": "episodes from the set", + "type": "text" + }, + { + "bbox": [ + 411, + 137, + 483, + 149 + ], + "score": 0.92, + "content": "\\{ 0 , 0 . 1 , 0 . 2 , . . . , 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 137, + 505, + 151 + ], + "score": 1.0, + "content": ". The", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 148, + 348, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 348, + 162 + ], + "score": 1.0, + "content": "blue curve corresponds to the asymmetric self-play training.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 107, + 165, + 505, + 231 + ], + "lines": [ + { + "bbox": [ + 105, + 164, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 505, + 178 + ], + "score": 1.0, + "content": "We can see that at the very beginning, a random policy for Alice gives some form of curriculum", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "score": 1.0, + "content": "but eventually is harmful, because Bob never gets to see any long treks. On the other hand, policy", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 505, + 199 + ], + "score": 1.0, + "content": "gradient sees very few successes in the beginning, and so trains slowly. Using the self-play method,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 199, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 106, + 199, + 505, + 210 + ], + "score": 1.0, + "content": "Alice gives Bob easy problems at first (she starts from random), and then builds harder and harder", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 209, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 505, + 222 + ], + "score": 1.0, + "content": "problems as the training progresses, finally matching the performance boost of the count based", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 220, + 498, + 233 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 498, + 233 + ], + "score": 1.0, + "content": "exploration. Although not shown, similar patterns are observed for a wide range of learning rates.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 9.5 + }, + { + "type": "title", + "bbox": [ + 107, + 243, + 234, + 254 + ], + "lines": [ + { + "bbox": [ + 106, + 242, + 236, + 255 + ], + "spans": [ + { + "bbox": [ + 106, + 242, + 236, + 255 + ], + "score": 1.0, + "content": "4.2 MAZEBASE: LIGHT KEY", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 265, + 504, + 309 + ], + "lines": [ + { + "bbox": [ + 106, + 265, + 505, + 277 + ], + "spans": [ + { + "bbox": [ + 106, + 265, + 505, + 277 + ], + "score": 1.0, + "content": "We now describe experiments using the MazeBase environment (Sukhbaatar et al., 2015), which", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 276, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 505, + 288 + ], + "score": 1.0, + "content": "have discrete actions and states, but sufficient combinatorial complexity that tabular methods can-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 286, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 505, + 300 + ], + "score": 1.0, + "content": "not be used. The environment consist of various items placed on a finite 2D grid; and randomly", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 298, + 218, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 218, + 310 + ], + "score": 1.0, + "content": "generated for each episode.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 107, + 315, + 504, + 370 + ], + "lines": [ + { + "bbox": [ + 106, + 314, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 314, + 505, + 327 + ], + "score": 1.0, + "content": "We use an environment where the maze contains a light switch (whose initial state is sampled ac-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 326, + 505, + 338 + ], + "spans": [ + { + "bbox": [ + 106, + 326, + 505, + 338 + ], + "score": 1.0, + "content": "cording to a predefined probability, p(Light off)), a key and a wall with a door (see Fig. 1). An agent", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 336, + 505, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 505, + 350 + ], + "score": 1.0, + "content": "can open or close the door by toggling the key switch, and turn on or off light with the light switch.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 346, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 346, + 506, + 361 + ], + "score": 1.0, + "content": "When the light is off, the agent can only see the (glowing) light switch. In the target task, there is", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 358, + 412, + 372 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 412, + 372 + ], + "score": 1.0, + "content": "also a goal flag item, and the objective of the game is reach to that goal flag.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 375, + 505, + 430 + ], + "lines": [ + { + "bbox": [ + 105, + 374, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 505, + 388 + ], + "score": 1.0, + "content": "In self-play, the environment is the same except there is no specific objective. An episode starts", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 386, + 505, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 505, + 399 + ], + "score": 1.0, + "content": "with Alice in control, who can navigate through the maze and change the switch states until she", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 397, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 505, + 410 + ], + "score": 1.0, + "content": "outputs the STOP action. Then, Bob takes control and tries to return everything to its original state", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 408, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 408, + 505, + 420 + ], + "score": 1.0, + "content": "(restricted to visible items) in the reverse self-play. In the repeat version, the maze resets back to its", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 420, + 434, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 420, + 434, + 432 + ], + "score": 1.0, + "content": "initial state when Bob takes the control, who tries to reach the final state of Alice.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 107, + 436, + 505, + 492 + ], + "lines": [ + { + "bbox": [ + 105, + 434, + 506, + 450 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 249, + 450 + ], + "score": 1.0, + "content": "In Fig. 2 (right), we set p(Light off)", + "type": "text" + }, + { + "bbox": [ + 249, + 437, + 268, + 447 + ], + "score": 0.58, + "content": "= 0 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 434, + 506, + 450 + ], + "score": 1.0, + "content": "during self-play3 and evaluate the repeat form of self-play,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 447, + 506, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 506, + 460 + ], + "score": 1.0, + "content": "alongside two baselines: (i) target task only training (i.e. no self-play) and (ii) self-play with a", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 457, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 104, + 457, + 506, + 473 + ], + "score": 1.0, + "content": "random policy for Alice. With self-play, the agent succeeds quickly while target task-only training", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 469, + 505, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 505, + 482 + ], + "score": 1.0, + "content": "takes much longer4. Fig. 3 shows details of a single training run, demonstrating how Alice and Bob", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 479, + 390, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 479, + 390, + 494 + ], + "score": 1.0, + "content": "automatically build a curriculum between themselves though self-play.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30 + }, + { + "type": "title", + "bbox": [ + 107, + 508, + 240, + 520 + ], + "lines": [ + { + "bbox": [ + 105, + 506, + 242, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 242, + 522 + ], + "score": 1.0, + "content": "4.3 RLLAB: MOUNTAIN CAR", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 107, + 530, + 505, + 596 + ], + "lines": [ + { + "bbox": [ + 106, + 531, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 505, + 543 + ], + "score": 1.0, + "content": "We applied our approach to the Mountain Car task in RLLab. Here the agent controls a car trapped in", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 541, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 104, + 541, + 505, + 555 + ], + "score": 1.0, + "content": "a 1-D valley. It must learn to build momentum by alternately moving to the left and right, climbing", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 552, + 506, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 506, + 565 + ], + "score": 1.0, + "content": "higher up the valley walls until it is able to escape. Although the problem is presented as continuous,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 564, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 505, + 577 + ], + "score": 1.0, + "content": "we discretize the 1-D action space into 5 bins (uniformly sized) enabling us to use discrete policy", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 574, + 506, + 587 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 506, + 587 + ], + "score": 1.0, + "content": "gradient, as above. We also added a secondary action head with binary actions to be used as STOP", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 585, + 420, + 597 + ], + "spans": [ + { + "bbox": [ + 106, + 585, + 231, + 597 + ], + "score": 1.0, + "content": "action. An observation of state", + "type": "text" + }, + { + "bbox": [ + 231, + 587, + 241, + 597 + ], + "score": 0.84, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 585, + 420, + 597 + ], + "score": 1.0, + "content": "consists of the location and speed of the car.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 107, + 602, + 505, + 636 + ], + "lines": [ + { + "bbox": [ + 106, + 602, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 602, + 348, + 614 + ], + "score": 1.0, + "content": "As in Houthooft et al. (2016); Tang et al. (2016), a reward of", + "type": "text" + }, + { + "bbox": [ + 348, + 603, + 360, + 613 + ], + "score": 0.84, + "content": "+ 1", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 602, + 505, + 614 + ], + "score": 1.0, + "content": "is given only when the car succeeds", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 613, + 505, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 311, + 626 + ], + "score": 1.0, + "content": "in climbing the hill. In self-play, Bob succeeds if", + "type": "text" + }, + { + "bbox": [ + 311, + 614, + 381, + 626 + ], + "score": 0.92, + "content": "\\| s _ { b } - s _ { a } \\| < 0 . 2", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 613, + 412, + 626 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 412, + 615, + 423, + 624 + ], + "score": 0.86, + "content": "s _ { a }", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 613, + 442, + 626 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 443, + 615, + 452, + 624 + ], + "score": 0.84, + "content": "s _ { b }", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 613, + 505, + 626 + ], + "score": 1.0, + "content": "are the final", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 624, + 387, + 637 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 387, + 637 + ], + "score": 1.0, + "content": "states (location and velocity of the car) of Alice and Bob respectively.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 107, + 641, + 505, + 686 + ], + "lines": [ + { + "bbox": [ + 105, + 640, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 505, + 654 + ], + "score": 1.0, + "content": "The nature of the environment makes it highly asymmetric from Alice and Bob’s point of view,", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 653, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 106, + 653, + 505, + 664 + ], + "score": 1.0, + "content": "since it is far easier to coast down the hill to the starting point that it is to climb up it. Hence we", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 663, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 505, + 675 + ], + "score": 1.0, + "content": "exclusively use the reset form of self-play. In Fig. 4 (left), we compare this to current state-of-the-art", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 674, + 504, + 686 + ], + "spans": [ + { + "bbox": [ + 106, + 674, + 504, + 686 + ], + "score": 1.0, + "content": "methods, namely VIME (Houthooft et al., 2016) and SimHash (Tang et al., 2016). Our approach", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 44.5 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 700, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 118, + 699, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 118, + 699, + 506, + 713 + ], + "score": 1.0, + "content": "3Changing p(Light off) adjusts the seperation between the self-play and target tasks. For a systematic", + "type": "text" + } + ] + }, + { + "bbox": [ + 105, + 710, + 268, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 268, + 722 + ], + "score": 1.0, + "content": "evaluation of this, please see Appendix C.1 .", + "type": "text" + } + ] + }, + { + "bbox": [ + 118, + 719, + 401, + 733 + ], + "spans": [ + { + "bbox": [ + 118, + 719, + 334, + 733 + ], + "score": 1.0, + "content": "4Training was stopped for all methods except target-only at", + "type": "text" + }, + { + "bbox": [ + 334, + 721, + 364, + 731 + ], + "score": 0.9, + "content": "5 \\times 1 0 ^ { 6 }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 719, + 401, + 733 + ], + "score": 1.0, + "content": "episodes.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 310, + 762 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 160 + ], + "lines": [], + "index": 3, + "bbox_fs": [ + 105, + 82, + 506, + 162 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 165, + 505, + 231 + ], + "lines": [ + { + "bbox": [ + 105, + 164, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 505, + 178 + ], + "score": 1.0, + "content": "We can see that at the very beginning, a random policy for Alice gives some form of curriculum", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "score": 1.0, + "content": "but eventually is harmful, because Bob never gets to see any long treks. On the other hand, policy", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 505, + 199 + ], + "score": 1.0, + "content": "gradient sees very few successes in the beginning, and so trains slowly. Using the self-play method,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 199, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 106, + 199, + 505, + 210 + ], + "score": 1.0, + "content": "Alice gives Bob easy problems at first (she starts from random), and then builds harder and harder", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 209, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 505, + 222 + ], + "score": 1.0, + "content": "problems as the training progresses, finally matching the performance boost of the count based", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 220, + 498, + 233 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 498, + 233 + ], + "score": 1.0, + "content": "exploration. Although not shown, similar patterns are observed for a wide range of learning rates.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 164, + 505, + 233 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 243, + 234, + 254 + ], + "lines": [ + { + "bbox": [ + 106, + 242, + 236, + 255 + ], + "spans": [ + { + "bbox": [ + 106, + 242, + 236, + 255 + ], + "score": 1.0, + "content": "4.2 MAZEBASE: LIGHT KEY", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 265, + 504, + 309 + ], + "lines": [ + { + "bbox": [ + 106, + 265, + 505, + 277 + ], + "spans": [ + { + "bbox": [ + 106, + 265, + 505, + 277 + ], + "score": 1.0, + "content": "We now describe experiments using the MazeBase environment (Sukhbaatar et al., 2015), which", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 276, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 505, + 288 + ], + "score": 1.0, + "content": "have discrete actions and states, but sufficient combinatorial complexity that tabular methods can-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 286, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 505, + 300 + ], + "score": 1.0, + "content": "not be used. The environment consist of various items placed on a finite 2D grid; and randomly", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 298, + 218, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 218, + 310 + ], + "score": 1.0, + "content": "generated for each episode.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 265, + 505, + 310 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 315, + 504, + 370 + ], + "lines": [ + { + "bbox": [ + 106, + 314, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 314, + 505, + 327 + ], + "score": 1.0, + "content": "We use an environment where the maze contains a light switch (whose initial state is sampled ac-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 326, + 505, + 338 + ], + "spans": [ + { + "bbox": [ + 106, + 326, + 505, + 338 + ], + "score": 1.0, + "content": "cording to a predefined probability, p(Light off)), a key and a wall with a door (see Fig. 1). An agent", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 336, + 505, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 505, + 350 + ], + "score": 1.0, + "content": "can open or close the door by toggling the key switch, and turn on or off light with the light switch.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 346, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 346, + 506, + 361 + ], + "score": 1.0, + "content": "When the light is off, the agent can only see the (glowing) light switch. In the target task, there is", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 358, + 412, + 372 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 412, + 372 + ], + "score": 1.0, + "content": "also a goal flag item, and the objective of the game is reach to that goal flag.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20, + "bbox_fs": [ + 105, + 314, + 506, + 372 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 375, + 505, + 430 + ], + "lines": [ + { + "bbox": [ + 105, + 374, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 505, + 388 + ], + "score": 1.0, + "content": "In self-play, the environment is the same except there is no specific objective. An episode starts", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 386, + 505, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 505, + 399 + ], + "score": 1.0, + "content": "with Alice in control, who can navigate through the maze and change the switch states until she", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 397, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 505, + 410 + ], + "score": 1.0, + "content": "outputs the STOP action. Then, Bob takes control and tries to return everything to its original state", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 408, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 408, + 505, + 420 + ], + "score": 1.0, + "content": "(restricted to visible items) in the reverse self-play. In the repeat version, the maze resets back to its", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 420, + 434, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 420, + 434, + 432 + ], + "score": 1.0, + "content": "initial state when Bob takes the control, who tries to reach the final state of Alice.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 374, + 505, + 432 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 436, + 505, + 492 + ], + "lines": [ + { + "bbox": [ + 105, + 434, + 506, + 450 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 249, + 450 + ], + "score": 1.0, + "content": "In Fig. 2 (right), we set p(Light off)", + "type": "text" + }, + { + "bbox": [ + 249, + 437, + 268, + 447 + ], + "score": 0.58, + "content": "= 0 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 434, + 506, + 450 + ], + "score": 1.0, + "content": "during self-play3 and evaluate the repeat form of self-play,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 447, + 506, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 506, + 460 + ], + "score": 1.0, + "content": "alongside two baselines: (i) target task only training (i.e. no self-play) and (ii) self-play with a", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 457, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 104, + 457, + 506, + 473 + ], + "score": 1.0, + "content": "random policy for Alice. With self-play, the agent succeeds quickly while target task-only training", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 469, + 505, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 505, + 482 + ], + "score": 1.0, + "content": "takes much longer4. Fig. 3 shows details of a single training run, demonstrating how Alice and Bob", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 479, + 390, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 479, + 390, + 494 + ], + "score": 1.0, + "content": "automatically build a curriculum between themselves though self-play.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30, + "bbox_fs": [ + 104, + 434, + 506, + 494 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 508, + 240, + 520 + ], + "lines": [ + { + "bbox": [ + 105, + 506, + 242, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 242, + 522 + ], + "score": 1.0, + "content": "4.3 RLLAB: MOUNTAIN CAR", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 107, + 530, + 505, + 596 + ], + "lines": [ + { + "bbox": [ + 106, + 531, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 505, + 543 + ], + "score": 1.0, + "content": "We applied our approach to the Mountain Car task in RLLab. Here the agent controls a car trapped in", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 541, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 104, + 541, + 505, + 555 + ], + "score": 1.0, + "content": "a 1-D valley. It must learn to build momentum by alternately moving to the left and right, climbing", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 552, + 506, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 506, + 565 + ], + "score": 1.0, + "content": "higher up the valley walls until it is able to escape. Although the problem is presented as continuous,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 564, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 505, + 577 + ], + "score": 1.0, + "content": "we discretize the 1-D action space into 5 bins (uniformly sized) enabling us to use discrete policy", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 574, + 506, + 587 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 506, + 587 + ], + "score": 1.0, + "content": "gradient, as above. We also added a secondary action head with binary actions to be used as STOP", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 585, + 420, + 597 + ], + "spans": [ + { + "bbox": [ + 106, + 585, + 231, + 597 + ], + "score": 1.0, + "content": "action. An observation of state", + "type": "text" + }, + { + "bbox": [ + 231, + 587, + 241, + 597 + ], + "score": 0.84, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 585, + 420, + 597 + ], + "score": 1.0, + "content": "consists of the location and speed of the car.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36.5, + "bbox_fs": [ + 104, + 531, + 506, + 597 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 602, + 505, + 636 + ], + "lines": [ + { + "bbox": [ + 106, + 602, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 602, + 348, + 614 + ], + "score": 1.0, + "content": "As in Houthooft et al. (2016); Tang et al. (2016), a reward of", + "type": "text" + }, + { + "bbox": [ + 348, + 603, + 360, + 613 + ], + "score": 0.84, + "content": "+ 1", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 602, + 505, + 614 + ], + "score": 1.0, + "content": "is given only when the car succeeds", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 613, + 505, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 311, + 626 + ], + "score": 1.0, + "content": "in climbing the hill. In self-play, Bob succeeds if", + "type": "text" + }, + { + "bbox": [ + 311, + 614, + 381, + 626 + ], + "score": 0.92, + "content": "\\| s _ { b } - s _ { a } \\| < 0 . 2", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 613, + 412, + 626 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 412, + 615, + 423, + 624 + ], + "score": 0.86, + "content": "s _ { a }", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 613, + 442, + 626 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 443, + 615, + 452, + 624 + ], + "score": 0.84, + "content": "s _ { b }", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 613, + 505, + 626 + ], + "score": 1.0, + "content": "are the final", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 624, + 387, + 637 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 387, + 637 + ], + "score": 1.0, + "content": "states (location and velocity of the car) of Alice and Bob respectively.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41, + "bbox_fs": [ + 105, + 602, + 505, + 637 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 641, + 505, + 686 + ], + "lines": [ + { + "bbox": [ + 105, + 640, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 505, + 654 + ], + "score": 1.0, + "content": "The nature of the environment makes it highly asymmetric from Alice and Bob’s point of view,", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 653, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 106, + 653, + 505, + 664 + ], + "score": 1.0, + "content": "since it is far easier to coast down the hill to the starting point that it is to climb up it. Hence we", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 663, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 505, + 675 + ], + "score": 1.0, + "content": "exclusively use the reset form of self-play. In Fig. 4 (left), we compare this to current state-of-the-art", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 674, + 504, + 686 + ], + "spans": [ + { + "bbox": [ + 106, + 674, + 504, + 686 + ], + "score": 1.0, + "content": "methods, namely VIME (Houthooft et al., 2016) and SimHash (Tang et al., 2016). Our approach", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 537, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 505, + 550 + ], + "score": 1.0, + "content": "(blue) performs comparably to both of these. We also tried using policy gradient directly on the", + "type": "text", + "cross_page": true + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 549, + 344, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 344, + 561 + ], + "score": 1.0, + "content": "target task samples, but it was unable to solve the problem.", + "type": "text", + "cross_page": true + } + ], + "index": 23 + } + ], + "index": 44.5, + "bbox_fs": [ + 105, + 640, + 505, + 686 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 136, + 81, + 475, + 214 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 136, + 81, + 475, + 214 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 136, + 81, + 475, + 214 + ], + "spans": [ + { + "bbox": [ + 136, + 81, + 475, + 214 + ], + "score": 0.972, + "type": "image", + "image_path": "fd97037d7dfd8b0c298fff0cc2c18d95ac0f656b56a8068fb1ee8e614ef71d71.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 136, + 81, + 475, + 125.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 136, + 125.33333333333334, + 475, + 169.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 136, + 169.66666666666669, + 475, + 214.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 223, + 505, + 312 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 223, + 506, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 223, + 331, + 237 + ], + "score": 1.0, + "content": "Figure 2: Left: The hallway task from section 4.1. The", + "type": "text" + }, + { + "bbox": [ + 331, + 226, + 338, + 235 + ], + "score": 0.78, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 223, + 506, + 237 + ], + "score": 1.0, + "content": "axis is fraction of successes on the target", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 234, + 505, + 247 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 161, + 247 + ], + "score": 1.0, + "content": "task, and the", + "type": "text" + }, + { + "bbox": [ + 161, + 237, + 168, + 245 + ], + "score": 0.75, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 234, + 505, + 247 + ], + "score": 1.0, + "content": "axis is the total number of training examples seen. Standard policy gradient (red)", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 245, + 505, + 258 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 505, + 258 + ], + "score": 1.0, + "content": "learns slowly. Adding an explicit exploration bonus (Strehl & Littman, 2008) (green) helps signif-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 256, + 505, + 270 + ], + "spans": [ + { + "bbox": [ + 105, + 256, + 505, + 270 + ], + "score": 1.0, + "content": "icantly. Our self-play approach (blue) gives similar performance however. Using a random policy", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 267, + 505, + 280 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 505, + 280 + ], + "score": 1.0, + "content": "for Alice (magenta) drastically impairs performance, showing the importance of self-play between", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 277, + 505, + 292 + ], + "spans": [ + { + "bbox": [ + 105, + 277, + 405, + 292 + ], + "score": 1.0, + "content": "Alice and Bob. Right: Mazebase task, illustrated in Fig. 1, for p(Light off)", + "type": "text" + }, + { + "bbox": [ + 405, + 279, + 428, + 289 + ], + "score": 0.8, + "content": "= 0 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 277, + 505, + 292 + ], + "score": 1.0, + "content": ". Augmenting with", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 289, + 505, + 302 + ], + "spans": [ + { + "bbox": [ + 105, + 289, + 505, + 302 + ], + "score": 1.0, + "content": "the repeat form of self-play enables significantly faster learning than training on the target task alone", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 300, + 222, + 313 + ], + "spans": [ + { + "bbox": [ + 105, + 300, + 222, + 313 + ], + "score": 1.0, + "content": "and random Alice baselines.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6.5 + } + ], + "index": 3.75 + }, + { + "type": "image", + "bbox": [ + 107, + 336, + 505, + 423 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 336, + 505, + 423 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 107, + 336, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 107, + 336, + 505, + 423 + ], + "score": 0.969, + "type": "image", + "image_path": "f5ed4f61d0e7add8c1f00c093478873a71cfc2e186ade55e93fc03d269aa09ed.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 107, + 336, + 505, + 365.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 107, + 365.0, + 505, + 394.0 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 107, + 394.0, + 505, + 423.0 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 430, + 505, + 519 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "score": 1.0, + "content": "Figure 3: Inspection of a Mazebase learning run, using the environment shown in Fig. 1. (a): rate", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 441, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 505, + 453 + ], + "score": 1.0, + "content": "at which Alice interacts with 1, 2 or 3 objects during an episode, illustrating the automatically", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 453, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 505, + 464 + ], + "score": 1.0, + "content": "generated curriculum. Initially Alice touches no objects, but then starts to interact with one. But this", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 463, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 505, + 476 + ], + "score": 1.0, + "content": "rate drops as Alice devises tasks that involve two and subsequently three objects. (b) by contrast, in", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 474, + 506, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 506, + 487 + ], + "score": 1.0, + "content": "the random Alice baseline, she never utilizes more than a single object and even then at a much lower", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 104, + 484, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 104, + 484, + 446, + 498 + ], + "score": 1.0, + "content": "rate. (c) plot of Alice and Bob’s reward, which strongly correlates with (a). (d) plot of", + "type": "text" + }, + { + "bbox": [ + 447, + 486, + 456, + 496 + ], + "score": 0.87, + "content": "t _ { a }", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 484, + 505, + 498 + ], + "score": 1.0, + "content": "as self-play", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 497, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 505, + 509 + ], + "score": 1.0, + "content": "progresses. Alice takes an increasing amount of time before handing over to Bob, consistent with", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 508, + 263, + 520 + ], + "spans": [ + { + "bbox": [ + 106, + 508, + 263, + 520 + ], + "score": 1.0, + "content": "tasks of increasing difficulty being set.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 17.5 + } + ], + "index": 14.75 + }, + { + "type": "text", + "bbox": [ + 106, + 537, + 503, + 560 + ], + "lines": [ + { + "bbox": [ + 106, + 537, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 505, + 550 + ], + "score": 1.0, + "content": "(blue) performs comparably to both of these. We also tried using policy gradient directly on the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 549, + 344, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 344, + 561 + ], + "score": 1.0, + "content": "target task samples, but it was unable to solve the problem.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "title", + "bbox": [ + 108, + 581, + 249, + 592 + ], + "lines": [ + { + "bbox": [ + 106, + 581, + 251, + 593 + ], + "spans": [ + { + "bbox": [ + 106, + 581, + 251, + 593 + ], + "score": 1.0, + "content": "4.4 RLLAB: SWIMMERGATHER", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 604, + 505, + 671 + ], + "lines": [ + { + "bbox": [ + 106, + 604, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 106, + 604, + 505, + 617 + ], + "score": 1.0, + "content": "We also applied our approach to the SwimmerGather task in RLLab (which uses the Mu-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 615, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 629 + ], + "score": 1.0, + "content": "joco (Todorov et al., 2012) simulator), where the agent controls a worm with two flexible joints,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 627, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 398, + 640 + ], + "score": 1.0, + "content": "swimming in a 2D viscous fluid. In the target task, the agent gets reward", + "type": "text" + }, + { + "bbox": [ + 398, + 627, + 410, + 637 + ], + "score": 0.83, + "content": "+ 1", + "type": "inline_equation" + }, + { + "bbox": [ + 411, + 627, + 505, + 640 + ], + "score": 1.0, + "content": "for eating green apples", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 505, + 650 + ], + "score": 1.0, + "content": "and -1 for touching red bombs, which are not present during self-play. Thus the self-play task and", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 648, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 505, + 661 + ], + "score": 1.0, + "content": "target tasks are different: in the former, the worm just swims around but in the latter it must learn to", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 660, + 339, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 660, + 339, + 672 + ], + "score": 1.0, + "content": "swim towards green apples and away from the red bombs.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 107, + 677, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 676, + 505, + 689 + ], + "score": 1.0, + "content": "The observation state consists of a 13-dimensional vector describing location and joint angles of the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "worm, and a 20 dimensional vector for sensing nearby objects. The worm takes two real values as", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "an action, each controlling one joint. We add a secondary action head to our models to handle the", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "2nd joint, and a third binary action head for STOP action. As in the mountain car, we discretize the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "score": 1.0, + "content": "output space (each joint is given 9 uniformly sized bins) to allow the use of discrete policy gradients.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 303, + 751, + 309, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 136, + 81, + 475, + 214 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 136, + 81, + 475, + 214 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 136, + 81, + 475, + 214 + ], + "spans": [ + { + "bbox": [ + 136, + 81, + 475, + 214 + ], + "score": 0.972, + "type": "image", + "image_path": "fd97037d7dfd8b0c298fff0cc2c18d95ac0f656b56a8068fb1ee8e614ef71d71.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 136, + 81, + 475, + 125.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 136, + 125.33333333333334, + 475, + 169.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 136, + 169.66666666666669, + 475, + 214.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 223, + 505, + 312 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 223, + 506, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 223, + 331, + 237 + ], + "score": 1.0, + "content": "Figure 2: Left: The hallway task from section 4.1. The", + "type": "text" + }, + { + "bbox": [ + 331, + 226, + 338, + 235 + ], + "score": 0.78, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 223, + 506, + 237 + ], + "score": 1.0, + "content": "axis is fraction of successes on the target", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 234, + 505, + 247 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 161, + 247 + ], + "score": 1.0, + "content": "task, and the", + "type": "text" + }, + { + "bbox": [ + 161, + 237, + 168, + 245 + ], + "score": 0.75, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 234, + 505, + 247 + ], + "score": 1.0, + "content": "axis is the total number of training examples seen. Standard policy gradient (red)", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 245, + 505, + 258 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 505, + 258 + ], + "score": 1.0, + "content": "learns slowly. Adding an explicit exploration bonus (Strehl & Littman, 2008) (green) helps signif-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 256, + 505, + 270 + ], + "spans": [ + { + "bbox": [ + 105, + 256, + 505, + 270 + ], + "score": 1.0, + "content": "icantly. Our self-play approach (blue) gives similar performance however. Using a random policy", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 267, + 505, + 280 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 505, + 280 + ], + "score": 1.0, + "content": "for Alice (magenta) drastically impairs performance, showing the importance of self-play between", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 277, + 505, + 292 + ], + "spans": [ + { + "bbox": [ + 105, + 277, + 405, + 292 + ], + "score": 1.0, + "content": "Alice and Bob. Right: Mazebase task, illustrated in Fig. 1, for p(Light off)", + "type": "text" + }, + { + "bbox": [ + 405, + 279, + 428, + 289 + ], + "score": 0.8, + "content": "= 0 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 277, + 505, + 292 + ], + "score": 1.0, + "content": ". Augmenting with", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 289, + 505, + 302 + ], + "spans": [ + { + "bbox": [ + 105, + 289, + 505, + 302 + ], + "score": 1.0, + "content": "the repeat form of self-play enables significantly faster learning than training on the target task alone", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 300, + 222, + 313 + ], + "spans": [ + { + "bbox": [ + 105, + 300, + 222, + 313 + ], + "score": 1.0, + "content": "and random Alice baselines.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6.5 + } + ], + "index": 3.75 + }, + { + "type": "image", + "bbox": [ + 107, + 336, + 505, + 423 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 336, + 505, + 423 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 107, + 336, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 107, + 336, + 505, + 423 + ], + "score": 0.969, + "type": "image", + "image_path": "f5ed4f61d0e7add8c1f00c093478873a71cfc2e186ade55e93fc03d269aa09ed.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 107, + 336, + 505, + 365.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 107, + 365.0, + 505, + 394.0 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 107, + 394.0, + 505, + 423.0 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 430, + 505, + 519 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "score": 1.0, + "content": "Figure 3: Inspection of a Mazebase learning run, using the environment shown in Fig. 1. (a): rate", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 441, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 505, + 453 + ], + "score": 1.0, + "content": "at which Alice interacts with 1, 2 or 3 objects during an episode, illustrating the automatically", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 453, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 505, + 464 + ], + "score": 1.0, + "content": "generated curriculum. Initially Alice touches no objects, but then starts to interact with one. But this", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 463, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 505, + 476 + ], + "score": 1.0, + "content": "rate drops as Alice devises tasks that involve two and subsequently three objects. (b) by contrast, in", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 474, + 506, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 506, + 487 + ], + "score": 1.0, + "content": "the random Alice baseline, she never utilizes more than a single object and even then at a much lower", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 104, + 484, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 104, + 484, + 446, + 498 + ], + "score": 1.0, + "content": "rate. (c) plot of Alice and Bob’s reward, which strongly correlates with (a). (d) plot of", + "type": "text" + }, + { + "bbox": [ + 447, + 486, + 456, + 496 + ], + "score": 0.87, + "content": "t _ { a }", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 484, + 505, + 498 + ], + "score": 1.0, + "content": "as self-play", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 497, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 505, + 509 + ], + "score": 1.0, + "content": "progresses. Alice takes an increasing amount of time before handing over to Bob, consistent with", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 508, + 263, + 520 + ], + "spans": [ + { + "bbox": [ + 106, + 508, + 263, + 520 + ], + "score": 1.0, + "content": "tasks of increasing difficulty being set.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 17.5 + } + ], + "index": 14.75 + }, + { + "type": "text", + "bbox": [ + 106, + 537, + 503, + 560 + ], + "lines": [], + "index": 22.5, + "bbox_fs": [ + 105, + 537, + 505, + 561 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 108, + 581, + 249, + 592 + ], + "lines": [ + { + "bbox": [ + 106, + 581, + 251, + 593 + ], + "spans": [ + { + "bbox": [ + 106, + 581, + 251, + 593 + ], + "score": 1.0, + "content": "4.4 RLLAB: SWIMMERGATHER", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 604, + 505, + 671 + ], + "lines": [ + { + "bbox": [ + 106, + 604, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 106, + 604, + 505, + 617 + ], + "score": 1.0, + "content": "We also applied our approach to the SwimmerGather task in RLLab (which uses the Mu-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 615, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 629 + ], + "score": 1.0, + "content": "joco (Todorov et al., 2012) simulator), where the agent controls a worm with two flexible joints,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 627, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 398, + 640 + ], + "score": 1.0, + "content": "swimming in a 2D viscous fluid. In the target task, the agent gets reward", + "type": "text" + }, + { + "bbox": [ + 398, + 627, + 410, + 637 + ], + "score": 0.83, + "content": "+ 1", + "type": "inline_equation" + }, + { + "bbox": [ + 411, + 627, + 505, + 640 + ], + "score": 1.0, + "content": "for eating green apples", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 505, + 650 + ], + "score": 1.0, + "content": "and -1 for touching red bombs, which are not present during self-play. Thus the self-play task and", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 648, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 505, + 661 + ], + "score": 1.0, + "content": "target tasks are different: in the former, the worm just swims around but in the latter it must learn to", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 660, + 339, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 660, + 339, + 672 + ], + "score": 1.0, + "content": "swim towards green apples and away from the red bombs.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 604, + 505, + 672 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 677, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 676, + 505, + 689 + ], + "score": 1.0, + "content": "The observation state consists of a 13-dimensional vector describing location and joint angles of the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "worm, and a 20 dimensional vector for sensing nearby objects. The worm takes two real values as", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "an action, each controlling one joint. We add a secondary action head to our models to handle the", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "2nd joint, and a third binary action head for STOP action. As in the mountain car, we discretize the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "score": 1.0, + "content": "output space (each joint is given 9 uniformly sized bins) to allow the use of discrete policy gradients.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33, + "bbox_fs": [ + 105, + 676, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 505, + 171 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 280, + 95 + ], + "score": 1.0, + "content": "Bob succeeds in a self-play episode when", + "type": "text" + }, + { + "bbox": [ + 280, + 82, + 347, + 95 + ], + "score": 0.93, + "content": "\\| l _ { b } - l _ { a } \\| < 0 . 3", + "type": "inline_equation" + }, + { + "bbox": [ + 348, + 81, + 376, + 95 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 376, + 83, + 385, + 93 + ], + "score": 0.86, + "content": "l _ { a }", + "type": "inline_equation" + }, + { + "bbox": [ + 386, + 81, + 404, + 95 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 405, + 83, + 413, + 93 + ], + "score": 0.85, + "content": "l _ { b }", + "type": "inline_equation" + }, + { + "bbox": [ + 414, + 81, + 505, + 95 + ], + "score": 1.0, + "content": "are the final locations", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 107 + ], + "score": 1.0, + "content": "of Alice and Bob respectively. Fig. 4 (right) shows the target task reward as a function of training", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "iteration for our approach alongside state-of-the-art exploration methods VIME (Houthooft et al.,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "score": 1.0, + "content": "2016) and SimHash (Tang et al., 2016). We demonstrate the generality of the self-play approach by", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 506, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 506, + 138 + ], + "score": 1.0, + "content": "applying it to Reinforce and also TRPO (Schulman et al., 2015) (see Appendix D for details). In", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 136, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 136, + 505, + 150 + ], + "score": 1.0, + "content": "both cases, it enables them to gain reward significantly earlier than other methods, although both", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 149, + 505, + 160 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 505, + 160 + ], + "score": 1.0, + "content": "converge to a similar final value to SimHash. A video of our worm performing the test task can be", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 273, + 172 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 273, + 172 + ], + "score": 1.0, + "content": "found at https://goo.gl/Vsd8Js.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 3.5 + }, + { + "type": "image", + "bbox": [ + 115, + 181, + 495, + 299 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 115, + 181, + 495, + 299 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 115, + 181, + 495, + 299 + ], + "spans": [ + { + "bbox": [ + 115, + 181, + 495, + 299 + ], + "score": 0.968, + "type": "image", + "image_path": "7bc22b89f7cabb0fb8047c902b16342f1019591342f2ef3dd6922a1ef4dc3629.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 115, + 181, + 495, + 220.33333333333334 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 115, + 220.33333333333334, + 495, + 259.6666666666667 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 115, + 259.6666666666667, + 495, + 299.0 + ], + "spans": [], + "index": 10 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 301, + 505, + 367 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 300, + 506, + 313 + ], + "spans": [ + { + "bbox": [ + 105, + 300, + 506, + 313 + ], + "score": 1.0, + "content": "Figure 4: Evaluation on MountainCar (left) and SwimmerGather (right) target tasks, comparing to", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 311, + 505, + 324 + ], + "spans": [ + { + "bbox": [ + 105, + 311, + 505, + 324 + ], + "score": 1.0, + "content": "VIME Houthooft et al. (2016) and SimHash Tang et al. (2016) (figures adapted from Tang et al.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 322, + 505, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 505, + 335 + ], + "score": 1.0, + "content": "(2016)). With reversible self-play we are able to learn faster than the other approaches, although", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 333, + 506, + 346 + ], + "spans": [ + { + "bbox": [ + 105, + 333, + 506, + 346 + ], + "score": 1.0, + "content": "it converges to a comparable reward. Training directly on the target task using Reinforce without", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 344, + 506, + 357 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 316, + 357 + ], + "score": 1.0, + "content": "self-play resulted in total failure. Here 1 iteration", + "type": "text" + }, + { + "bbox": [ + 317, + 345, + 339, + 355 + ], + "score": 0.81, + "content": "= 5 \\mathrm { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 344, + 506, + 357 + ], + "score": 1.0, + "content": "(50k) target task steps in Mountain car", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 355, + 288, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 355, + 288, + 369 + ], + "score": 1.0, + "content": "(SwimmerGather), excluding self-play steps.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13.5 + } + ], + "index": 11.25 + }, + { + "type": "title", + "bbox": [ + 109, + 371, + 275, + 383 + ], + "lines": [ + { + "bbox": [ + 106, + 370, + 276, + 384 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 276, + 384 + ], + "score": 1.0, + "content": "4.5 STARCRAFT: TRAINING MARINES", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 392, + 505, + 457 + ], + "lines": [ + { + "bbox": [ + 105, + 391, + 504, + 405 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 504, + 405 + ], + "score": 1.0, + "content": "Finally, we applied our self-play approach to the same setup as the beginning of a standard StarCraft:", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 402, + 506, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 506, + 416 + ], + "score": 1.0, + "content": "Brood War game Synnaeve et al. (2016), where an agent controls multiple units to mine, construct", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 414, + 505, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 505, + 426 + ], + "score": 1.0, + "content": "buildings, and train new units, but without enemies to fight. The environment starts with 4 workers", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 425, + 505, + 438 + ], + "spans": [ + { + "bbox": [ + 106, + 425, + 505, + 438 + ], + "score": 1.0, + "content": "units (Terran SCVs), who can move around, mine nearby minerals and construct new buildings. In", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 437, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 437, + 505, + 448 + ], + "score": 1.0, + "content": "addition, the agent controls the command center, which can train new workers. See Fig. 5 (left) for", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 448, + 308, + 458 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 308, + 458 + ], + "score": 1.0, + "content": "relations between different units and their actions.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 107, + 463, + 505, + 563 + ], + "lines": [ + { + "bbox": [ + 106, + 464, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 106, + 464, + 505, + 476 + ], + "score": 1.0, + "content": "The target task is to build Marine units. To do this, an agent must follow a specific sequence of", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 475, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 506, + 488 + ], + "score": 1.0, + "content": "operations: (i) mine minerals with workers; (ii) having accumulated sufficient mineral supply, build", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 104, + 485, + 506, + 499 + ], + "spans": [ + { + "bbox": [ + 104, + 485, + 506, + 499 + ], + "score": 1.0, + "content": "a barracks and (iii) once the barracks are complete, train Marine units out of it. Optionally, an agent", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 497, + 506, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 506, + 510 + ], + "score": 1.0, + "content": "can train a new worker for faster mining, or build a supply depot to accommodate more units. When", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 507, + 506, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 425, + 520 + ], + "score": 1.0, + "content": "the episode ends after 200 steps (little over 3 minutes), the agent gets rewarded", + "type": "text" + }, + { + "bbox": [ + 425, + 508, + 437, + 518 + ], + "score": 0.82, + "content": "+ 1", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 507, + 506, + 520 + ], + "score": 1.0, + "content": "for each Marine", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 519, + 506, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 519, + 506, + 532 + ], + "score": 1.0, + "content": "it has built. Optimizing this task is highly complex due to several factors. First, the agent has to", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 529, + 506, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 506, + 543 + ], + "score": 1.0, + "content": "find an optimal mining pattern (concentrating on a single mineral or mining a far away mineral is", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 538, + 506, + 555 + ], + "spans": [ + { + "bbox": [ + 104, + 538, + 506, + 555 + ], + "score": 1.0, + "content": "inefficient). Then, it has to produce the optimal number of workers and barrack at the right timing.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 551, + 468, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 468, + 564 + ], + "score": 1.0, + "content": "In addition, a supply depot needs to be built when the number of units is close to the limit.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 568, + 505, + 657 + ], + "lines": [ + { + "bbox": [ + 105, + 568, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 568, + 505, + 581 + ], + "score": 1.0, + "content": "During self-play (repeat variant), Alice and Bob control the workers and can try any combination", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 579, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 506, + 592 + ], + "score": 1.0, + "content": "of actions during the episode. Since exactly matching the game state is almost impossible, Bob’s", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 591, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 505, + 603 + ], + "score": 1.0, + "content": "success is only based on the global state of the game, which includes the number of units of each", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 601, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 506, + 614 + ], + "score": 1.0, + "content": "type (including buildings), and accumulated mineral resource. So Bob’s objective in self-play is", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 613, + 506, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 506, + 625 + ], + "score": 1.0, + "content": "to make as many units and mineral as Alice in shortest possible time. Further details are given in", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 623, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 623, + 505, + 636 + ], + "score": 1.0, + "content": "Appendix E. Fig. 5 (right) compares the Reinforce algorithm on the target task, with and without", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 635, + 505, + 647 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 505, + 647 + ], + "score": 1.0, + "content": "self-play. An additional count-based exploration baseline similar to the hallway experiment is also", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 645, + 337, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 337, + 658 + ], + "score": 1.0, + "content": "shown. It utilizes the same global game state as self-play.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 36.5 + }, + { + "type": "title", + "bbox": [ + 107, + 673, + 190, + 686 + ], + "lines": [ + { + "bbox": [ + 105, + 672, + 192, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 672, + 192, + 689 + ], + "score": 1.0, + "content": "5 DISCUSSION", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "In this work we described a novel method for intrinsically motivated learning which we call asym-", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "metric self-play. Despite the method’s conceptual simplicity, we have seen that it can be effective", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "in both discrete and continuous input settings with function approximation, for encouraging ex-", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 761 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 761 + ], + "score": 1.0, + "content": "8", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 505, + 171 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 280, + 95 + ], + "score": 1.0, + "content": "Bob succeeds in a self-play episode when", + "type": "text" + }, + { + "bbox": [ + 280, + 82, + 347, + 95 + ], + "score": 0.93, + "content": "\\| l _ { b } - l _ { a } \\| < 0 . 3", + "type": "inline_equation" + }, + { + "bbox": [ + 348, + 81, + 376, + 95 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 376, + 83, + 385, + 93 + ], + "score": 0.86, + "content": "l _ { a }", + "type": "inline_equation" + }, + { + "bbox": [ + 386, + 81, + 404, + 95 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 405, + 83, + 413, + 93 + ], + "score": 0.85, + "content": "l _ { b }", + "type": "inline_equation" + }, + { + "bbox": [ + 414, + 81, + 505, + 95 + ], + "score": 1.0, + "content": "are the final locations", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 107 + ], + "score": 1.0, + "content": "of Alice and Bob respectively. Fig. 4 (right) shows the target task reward as a function of training", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "iteration for our approach alongside state-of-the-art exploration methods VIME (Houthooft et al.,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "score": 1.0, + "content": "2016) and SimHash (Tang et al., 2016). We demonstrate the generality of the self-play approach by", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 506, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 506, + 138 + ], + "score": 1.0, + "content": "applying it to Reinforce and also TRPO (Schulman et al., 2015) (see Appendix D for details). In", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 136, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 136, + 505, + 150 + ], + "score": 1.0, + "content": "both cases, it enables them to gain reward significantly earlier than other methods, although both", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 149, + 505, + 160 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 505, + 160 + ], + "score": 1.0, + "content": "converge to a similar final value to SimHash. A video of our worm performing the test task can be", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 273, + 172 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 273, + 172 + ], + "score": 1.0, + "content": "found at https://goo.gl/Vsd8Js.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 81, + 506, + 172 + ] + }, + { + "type": "image", + "bbox": [ + 115, + 181, + 495, + 299 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 115, + 181, + 495, + 299 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 115, + 181, + 495, + 299 + ], + "spans": [ + { + "bbox": [ + 115, + 181, + 495, + 299 + ], + "score": 0.968, + "type": "image", + "image_path": "7bc22b89f7cabb0fb8047c902b16342f1019591342f2ef3dd6922a1ef4dc3629.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 115, + 181, + 495, + 220.33333333333334 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 115, + 220.33333333333334, + 495, + 259.6666666666667 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 115, + 259.6666666666667, + 495, + 299.0 + ], + "spans": [], + "index": 10 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 301, + 505, + 367 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 300, + 506, + 313 + ], + "spans": [ + { + "bbox": [ + 105, + 300, + 506, + 313 + ], + "score": 1.0, + "content": "Figure 4: Evaluation on MountainCar (left) and SwimmerGather (right) target tasks, comparing to", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 311, + 505, + 324 + ], + "spans": [ + { + "bbox": [ + 105, + 311, + 505, + 324 + ], + "score": 1.0, + "content": "VIME Houthooft et al. (2016) and SimHash Tang et al. (2016) (figures adapted from Tang et al.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 322, + 505, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 505, + 335 + ], + "score": 1.0, + "content": "(2016)). With reversible self-play we are able to learn faster than the other approaches, although", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 333, + 506, + 346 + ], + "spans": [ + { + "bbox": [ + 105, + 333, + 506, + 346 + ], + "score": 1.0, + "content": "it converges to a comparable reward. Training directly on the target task using Reinforce without", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 344, + 506, + 357 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 316, + 357 + ], + "score": 1.0, + "content": "self-play resulted in total failure. Here 1 iteration", + "type": "text" + }, + { + "bbox": [ + 317, + 345, + 339, + 355 + ], + "score": 0.81, + "content": "= 5 \\mathrm { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 344, + 506, + 357 + ], + "score": 1.0, + "content": "(50k) target task steps in Mountain car", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 355, + 288, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 355, + 288, + 369 + ], + "score": 1.0, + "content": "(SwimmerGather), excluding self-play steps.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13.5 + } + ], + "index": 11.25 + }, + { + "type": "title", + "bbox": [ + 109, + 371, + 275, + 383 + ], + "lines": [ + { + "bbox": [ + 106, + 370, + 276, + 384 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 276, + 384 + ], + "score": 1.0, + "content": "4.5 STARCRAFT: TRAINING MARINES", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 392, + 505, + 457 + ], + "lines": [ + { + "bbox": [ + 105, + 391, + 504, + 405 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 504, + 405 + ], + "score": 1.0, + "content": "Finally, we applied our self-play approach to the same setup as the beginning of a standard StarCraft:", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 402, + 506, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 506, + 416 + ], + "score": 1.0, + "content": "Brood War game Synnaeve et al. (2016), where an agent controls multiple units to mine, construct", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 414, + 505, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 505, + 426 + ], + "score": 1.0, + "content": "buildings, and train new units, but without enemies to fight. The environment starts with 4 workers", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 425, + 505, + 438 + ], + "spans": [ + { + "bbox": [ + 106, + 425, + 505, + 438 + ], + "score": 1.0, + "content": "units (Terran SCVs), who can move around, mine nearby minerals and construct new buildings. In", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 437, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 437, + 505, + 448 + ], + "score": 1.0, + "content": "addition, the agent controls the command center, which can train new workers. See Fig. 5 (left) for", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 448, + 308, + 458 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 308, + 458 + ], + "score": 1.0, + "content": "relations between different units and their actions.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20.5, + "bbox_fs": [ + 105, + 391, + 506, + 458 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 463, + 505, + 563 + ], + "lines": [ + { + "bbox": [ + 106, + 464, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 106, + 464, + 505, + 476 + ], + "score": 1.0, + "content": "The target task is to build Marine units. To do this, an agent must follow a specific sequence of", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 475, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 506, + 488 + ], + "score": 1.0, + "content": "operations: (i) mine minerals with workers; (ii) having accumulated sufficient mineral supply, build", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 104, + 485, + 506, + 499 + ], + "spans": [ + { + "bbox": [ + 104, + 485, + 506, + 499 + ], + "score": 1.0, + "content": "a barracks and (iii) once the barracks are complete, train Marine units out of it. Optionally, an agent", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 497, + 506, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 506, + 510 + ], + "score": 1.0, + "content": "can train a new worker for faster mining, or build a supply depot to accommodate more units. When", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 507, + 506, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 425, + 520 + ], + "score": 1.0, + "content": "the episode ends after 200 steps (little over 3 minutes), the agent gets rewarded", + "type": "text" + }, + { + "bbox": [ + 425, + 508, + 437, + 518 + ], + "score": 0.82, + "content": "+ 1", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 507, + 506, + 520 + ], + "score": 1.0, + "content": "for each Marine", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 519, + 506, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 519, + 506, + 532 + ], + "score": 1.0, + "content": "it has built. Optimizing this task is highly complex due to several factors. First, the agent has to", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 529, + 506, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 506, + 543 + ], + "score": 1.0, + "content": "find an optimal mining pattern (concentrating on a single mineral or mining a far away mineral is", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 538, + 506, + 555 + ], + "spans": [ + { + "bbox": [ + 104, + 538, + 506, + 555 + ], + "score": 1.0, + "content": "inefficient). Then, it has to produce the optimal number of workers and barrack at the right timing.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 551, + 468, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 468, + 564 + ], + "score": 1.0, + "content": "In addition, a supply depot needs to be built when the number of units is close to the limit.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 28, + "bbox_fs": [ + 104, + 464, + 506, + 564 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 568, + 505, + 657 + ], + "lines": [ + { + "bbox": [ + 105, + 568, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 568, + 505, + 581 + ], + "score": 1.0, + "content": "During self-play (repeat variant), Alice and Bob control the workers and can try any combination", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 579, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 506, + 592 + ], + "score": 1.0, + "content": "of actions during the episode. Since exactly matching the game state is almost impossible, Bob’s", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 591, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 505, + 603 + ], + "score": 1.0, + "content": "success is only based on the global state of the game, which includes the number of units of each", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 601, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 506, + 614 + ], + "score": 1.0, + "content": "type (including buildings), and accumulated mineral resource. So Bob’s objective in self-play is", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 613, + 506, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 506, + 625 + ], + "score": 1.0, + "content": "to make as many units and mineral as Alice in shortest possible time. Further details are given in", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 623, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 623, + 505, + 636 + ], + "score": 1.0, + "content": "Appendix E. Fig. 5 (right) compares the Reinforce algorithm on the target task, with and without", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 635, + 505, + 647 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 505, + 647 + ], + "score": 1.0, + "content": "self-play. An additional count-based exploration baseline similar to the hallway experiment is also", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 645, + 337, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 337, + 658 + ], + "score": 1.0, + "content": "shown. It utilizes the same global game state as self-play.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 568, + 506, + 658 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 673, + 190, + 686 + ], + "lines": [ + { + "bbox": [ + 105, + 672, + 192, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 672, + 192, + 689 + ], + "score": 1.0, + "content": "5 DISCUSSION", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "In this work we described a novel method for intrinsically motivated learning which we call asym-", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "metric self-play. Despite the method’s conceptual simplicity, we have seen that it can be effective", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "in both discrete and continuous input settings with function approximation, for encouraging ex-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 306, + 505, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 505, + 319 + ], + "score": 1.0, + "content": "ploration and automatically generating curriculums. On the challenging benchmarks we consider,", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 317, + 505, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 317, + 505, + 330 + ], + "score": 1.0, + "content": "our approach is at least as good as state-of-the-art RL methods that incorporate an incentive for", + "type": "text", + "cross_page": true + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 327, + 506, + 341 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 506, + 341 + ], + "score": 1.0, + "content": "exploration, despite being based on very different principles. Furthermore, it is possible show the-", + "type": "text", + "cross_page": true + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 339, + 505, + 352 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 505, + 352 + ], + "score": 1.0, + "content": "oretically that in simple environments, using asymmetric self-play with reward functions from (1)", + "type": "text", + "cross_page": true + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 349, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 505, + 362 + ], + "score": 1.0, + "content": "and (2), optimal agents can transit between any pair of reachable states as efficiently as possible.", + "type": "text", + "cross_page": true + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 361, + 386, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 386, + 374 + ], + "score": 1.0, + "content": "Code for our approach can be found at (link removed for anonymity).", + "type": "text", + "cross_page": true + } + ], + "index": 15 + } + ], + "index": 43, + "bbox_fs": [ + 105, + 698, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 129, + 82, + 480, + 193 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 129, + 82, + 480, + 193 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 129, + 82, + 480, + 193 + ], + "spans": [ + { + "bbox": [ + 129, + 82, + 480, + 193 + ], + "score": 0.971, + "type": "image", + "image_path": "9d740b096917a0ed320f9d5dee4a1dea5a4333c2557c3fc29fe88147178a37a1.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 129, + 82, + 480, + 119.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 129, + 119.0, + 480, + 156.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 129, + 156.0, + 480, + 193.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 201, + 506, + 279 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 202, + 506, + 214 + ], + "spans": [ + { + "bbox": [ + 106, + 202, + 506, + 214 + ], + "score": 1.0, + "content": "Figure 5: Left: Different types of unit in the StarCraft environment. The arrows represent possible", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 213, + 506, + 226 + ], + "spans": [ + { + "bbox": [ + 105, + 213, + 506, + 226 + ], + "score": 1.0, + "content": "actions (excluding movement actions) by the unit, and corresponding numbers shows (blue) amount", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 224, + 505, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 224, + 505, + 236 + ], + "score": 1.0, + "content": "of minerals and (red) time steps needed to complete. The units under agent’s control are outlined by a", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 235, + 506, + 247 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 506, + 247 + ], + "score": 1.0, + "content": "green border. Right: Plot of reward on the StarCraft sub-task of training marine units vs #target-task", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 246, + 505, + 258 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 505, + 258 + ], + "score": 1.0, + "content": "episodes (self-play episodes are not included), with and without self-play. A count-based baseline", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 256, + 506, + 270 + ], + "spans": [ + { + "bbox": [ + 105, + 256, + 506, + 270 + ], + "score": 1.0, + "content": "is also shown. Self-play greatly speeds up learning, and also surpasses the count-based approach at", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 269, + 161, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 269, + 161, + 281 + ], + "score": 1.0, + "content": "convergence.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 306, + 505, + 372 + ], + "lines": [ + { + "bbox": [ + 105, + 306, + 505, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 505, + 319 + ], + "score": 1.0, + "content": "ploration and automatically generating curriculums. On the challenging benchmarks we consider,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 317, + 505, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 317, + 505, + 330 + ], + "score": 1.0, + "content": "our approach is at least as good as state-of-the-art RL methods that incorporate an incentive for", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 327, + 506, + 341 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 506, + 341 + ], + "score": 1.0, + "content": "exploration, despite being based on very different principles. Furthermore, it is possible show the-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 339, + 505, + 352 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 505, + 352 + ], + "score": 1.0, + "content": "oretically that in simple environments, using asymmetric self-play with reward functions from (1)", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 349, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 505, + 362 + ], + "score": 1.0, + "content": "and (2), optimal agents can transit between any pair of reachable states as efficiently as possible.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 361, + 386, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 386, + 374 + ], + "score": 1.0, + "content": "Code for our approach can be found at (link removed for anonymity).", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 12.5 + }, + { + "type": "title", + "bbox": [ + 107, + 390, + 175, + 402 + ], + "lines": [ + { + "bbox": [ + 106, + 388, + 177, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 388, + 177, + 404 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 108, + 408, + 503, + 442 + ], + "lines": [ + { + "bbox": [ + 106, + 407, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 106, + 407, + 505, + 421 + ], + "score": 1.0, + "content": "Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 419, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 115, + 419, + 505, + 432 + ], + "score": 1.0, + "content": "McGrew, Josh Tobin, Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. CoRR,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 115, + 430, + 424, + 443 + ], + "spans": [ + { + "bbox": [ + 115, + 430, + 424, + 443 + ], + "score": 1.0, + "content": "abs/1707.01495, 2017. URL http://arxiv.org/abs/1707.01495.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 102, + 450, + 504, + 473 + ], + "lines": [ + { + "bbox": [ + 105, + 450, + 505, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 505, + 462 + ], + "score": 1.0, + "content": "A. Baranes and P-Y. Oudeyer. Active learning of inverse models with intrinsically motivated goal", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 461, + 429, + 473 + ], + "spans": [ + { + "bbox": [ + 115, + 461, + 429, + 473 + ], + "score": 1.0, + "content": "exploration in robots. Robotics and Autonomous Systems, 61(1):49–73, 2013.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 106, + 480, + 503, + 504 + ], + "lines": [ + { + "bbox": [ + 106, + 480, + 505, + 493 + ], + "spans": [ + { + "bbox": [ + 106, + 480, + 505, + 493 + ], + "score": 1.0, + "content": "Andrew G. Barto. Intrinsic Motivation and Reinforcement Learning, pp. 17–47. Springer Berlin", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 492, + 190, + 504 + ], + "spans": [ + { + "bbox": [ + 116, + 492, + 190, + 504 + ], + "score": 1.0, + "content": "Heidelberg, 2013.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 106, + 511, + 504, + 545 + ], + "lines": [ + { + "bbox": [ + 106, + 511, + 504, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 504, + 523 + ], + "score": 1.0, + "content": "Marc G. Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi´", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 522, + 506, + 536 + ], + "spans": [ + { + "bbox": [ + 115, + 522, + 506, + 536 + ], + "score": 1.0, + "content": "Munos. Unifying count-based exploration and intrinsic motivation. In NIPS, pp. 1471–1479,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 531, + 144, + 546 + ], + "spans": [ + { + "bbox": [ + 115, + 531, + 144, + 546 + ], + "score": 1.0, + "content": "2016.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 107, + 553, + 504, + 576 + ], + "lines": [ + { + "bbox": [ + 105, + 551, + 506, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 506, + 566 + ], + "score": 1.0, + "content": "Yoshua Bengio, Jer´ ome Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In ˆ", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 564, + 215, + 577 + ], + "spans": [ + { + "bbox": [ + 116, + 564, + 215, + 577 + ], + "score": 1.0, + "content": "ICML, pp. 41–48, 2009.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 107, + 584, + 504, + 606 + ], + "lines": [ + { + "bbox": [ + 105, + 582, + 505, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 598 + ], + "score": 1.0, + "content": "Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 595, + 369, + 607 + ], + "spans": [ + { + "bbox": [ + 115, + 595, + 369, + 607 + ], + "score": 1.0, + "content": "reinforcement learning for continuous control. In ICML, 2016.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 106, + 614, + 504, + 648 + ], + "lines": [ + { + "bbox": [ + 106, + 615, + 505, + 627 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 505, + 627 + ], + "score": 1.0, + "content": "Carlos Florensa, David Held, Markus Wulfmeier, and Pieter Abbeel. Reverse curriculum generation", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 626, + 504, + 638 + ], + "spans": [ + { + "bbox": [ + 115, + 626, + 504, + 638 + ], + "score": 1.0, + "content": "for reinforcement learning. CoRR, abs/1707.05300, 2017. URL http://arxiv.org/abs/", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 637, + 182, + 648 + ], + "spans": [ + { + "bbox": [ + 116, + 637, + 182, + 648 + ], + "score": 1.0, + "content": "1707.05300.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 106, + 656, + 504, + 690 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 506, + 669 + ], + "score": 1.0, + "content": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 668, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 115, + 668, + 505, + 680 + ], + "score": 1.0, + "content": "Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, pp. 2672–2680,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 114, + 677, + 143, + 691 + ], + "spans": [ + { + "bbox": [ + 114, + 677, + 143, + 691 + ], + "score": 1.0, + "content": "2014.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "David Held, Xinyang Geng, Carlos Florensa, and Pieter Abbeel. Automatic goal generation for", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 114, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 114, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "reinforcement learning agents. CoRR, abs/1705.06366, 2017. URL http://arxiv.org/", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 721, + 205, + 732 + ], + "spans": [ + { + "bbox": [ + 116, + 721, + 205, + 732 + ], + "score": 1.0, + "content": "abs/1705.06366.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published 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": [ + 129, + 82, + 480, + 193 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 129, + 82, + 480, + 193 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 129, + 82, + 480, + 193 + ], + "spans": [ + { + "bbox": [ + 129, + 82, + 480, + 193 + ], + "score": 0.971, + "type": "image", + "image_path": "9d740b096917a0ed320f9d5dee4a1dea5a4333c2557c3fc29fe88147178a37a1.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 129, + 82, + 480, + 119.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 129, + 119.0, + 480, + 156.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 129, + 156.0, + 480, + 193.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 201, + 506, + 279 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 202, + 506, + 214 + ], + "spans": [ + { + "bbox": [ + 106, + 202, + 506, + 214 + ], + "score": 1.0, + "content": "Figure 5: Left: Different types of unit in the StarCraft environment. The arrows represent possible", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 213, + 506, + 226 + ], + "spans": [ + { + "bbox": [ + 105, + 213, + 506, + 226 + ], + "score": 1.0, + "content": "actions (excluding movement actions) by the unit, and corresponding numbers shows (blue) amount", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 224, + 505, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 224, + 505, + 236 + ], + "score": 1.0, + "content": "of minerals and (red) time steps needed to complete. The units under agent’s control are outlined by a", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 235, + 506, + 247 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 506, + 247 + ], + "score": 1.0, + "content": "green border. Right: Plot of reward on the StarCraft sub-task of training marine units vs #target-task", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 246, + 505, + 258 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 505, + 258 + ], + "score": 1.0, + "content": "episodes (self-play episodes are not included), with and without self-play. A count-based baseline", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 256, + 506, + 270 + ], + "spans": [ + { + "bbox": [ + 105, + 256, + 506, + 270 + ], + "score": 1.0, + "content": "is also shown. Self-play greatly speeds up learning, and also surpasses the count-based approach at", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 269, + 161, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 269, + 161, + 281 + ], + "score": 1.0, + "content": "convergence.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 306, + 505, + 372 + ], + "lines": [], + "index": 12.5, + "bbox_fs": [ + 105, + 306, + 506, + 374 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 107, + 390, + 175, + 402 + ], + "lines": [ + { + "bbox": [ + 106, + 388, + 177, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 388, + 177, + 404 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 108, + 408, + 503, + 442 + ], + "lines": [ + { + "bbox": [ + 106, + 407, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 106, + 407, + 505, + 421 + ], + "score": 1.0, + "content": "Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 419, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 115, + 419, + 505, + 432 + ], + "score": 1.0, + "content": "McGrew, Josh Tobin, Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. CoRR,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 115, + 430, + 424, + 443 + ], + "spans": [ + { + "bbox": [ + 115, + 430, + 424, + 443 + ], + "score": 1.0, + "content": "abs/1707.01495, 2017. URL http://arxiv.org/abs/1707.01495.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 106, + 407, + 505, + 443 + ] + }, + { + "type": "text", + "bbox": [ + 102, + 450, + 504, + 473 + ], + "lines": [ + { + "bbox": [ + 105, + 450, + 505, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 505, + 462 + ], + "score": 1.0, + "content": "A. Baranes and P-Y. Oudeyer. Active learning of inverse models with intrinsically motivated goal", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 461, + 429, + 473 + ], + "spans": [ + { + "bbox": [ + 115, + 461, + 429, + 473 + ], + "score": 1.0, + "content": "exploration in robots. Robotics and Autonomous Systems, 61(1):49–73, 2013.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20.5, + "bbox_fs": [ + 105, + 450, + 505, + 473 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 480, + 503, + 504 + ], + "lines": [ + { + "bbox": [ + 106, + 480, + 505, + 493 + ], + "spans": [ + { + "bbox": [ + 106, + 480, + 505, + 493 + ], + "score": 1.0, + "content": "Andrew G. Barto. Intrinsic Motivation and Reinforcement Learning, pp. 17–47. Springer Berlin", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 492, + 190, + 504 + ], + "spans": [ + { + "bbox": [ + 116, + 492, + 190, + 504 + ], + "score": 1.0, + "content": "Heidelberg, 2013.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 106, + 480, + 505, + 504 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 511, + 504, + 545 + ], + "lines": [ + { + "bbox": [ + 106, + 511, + 504, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 504, + 523 + ], + "score": 1.0, + "content": "Marc G. Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi´", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 522, + 506, + 536 + ], + "spans": [ + { + "bbox": [ + 115, + 522, + 506, + 536 + ], + "score": 1.0, + "content": "Munos. Unifying count-based exploration and intrinsic motivation. In NIPS, pp. 1471–1479,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 531, + 144, + 546 + ], + "spans": [ + { + "bbox": [ + 115, + 531, + 144, + 546 + ], + "score": 1.0, + "content": "2016.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25, + "bbox_fs": [ + 106, + 511, + 506, + 546 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 553, + 504, + 576 + ], + "lines": [ + { + "bbox": [ + 105, + 551, + 506, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 506, + 566 + ], + "score": 1.0, + "content": "Yoshua Bengio, Jer´ ome Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In ˆ", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 564, + 215, + 577 + ], + "spans": [ + { + "bbox": [ + 116, + 564, + 215, + 577 + ], + "score": 1.0, + "content": "ICML, pp. 41–48, 2009.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 551, + 506, + 577 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 584, + 504, + 606 + ], + "lines": [ + { + "bbox": [ + 105, + 582, + 505, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 598 + ], + "score": 1.0, + "content": "Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 595, + 369, + 607 + ], + "spans": [ + { + "bbox": [ + 115, + 595, + 369, + 607 + ], + "score": 1.0, + "content": "reinforcement learning for continuous control. In ICML, 2016.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5, + "bbox_fs": [ + 105, + 582, + 505, + 607 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 614, + 504, + 648 + ], + "lines": [ + { + "bbox": [ + 106, + 615, + 505, + 627 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 505, + 627 + ], + "score": 1.0, + "content": "Carlos Florensa, David Held, Markus Wulfmeier, and Pieter Abbeel. Reverse curriculum generation", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 626, + 504, + 638 + ], + "spans": [ + { + "bbox": [ + 115, + 626, + 504, + 638 + ], + "score": 1.0, + "content": "for reinforcement learning. CoRR, abs/1707.05300, 2017. URL http://arxiv.org/abs/", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 637, + 182, + 648 + ], + "spans": [ + { + "bbox": [ + 116, + 637, + 182, + 648 + ], + "score": 1.0, + "content": "1707.05300.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32, + "bbox_fs": [ + 106, + 615, + 505, + 648 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 656, + 504, + 690 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 506, + 669 + ], + "score": 1.0, + "content": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 668, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 115, + 668, + 505, + 680 + ], + "score": 1.0, + "content": "Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, pp. 2672–2680,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 114, + 677, + 143, + 691 + ], + "spans": [ + { + "bbox": [ + 114, + 677, + 143, + 691 + ], + "score": 1.0, + "content": "2014.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 655, + 506, + 691 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "David Held, Xinyang Geng, Carlos Florensa, and Pieter Abbeel. Automatic goal generation for", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 114, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 114, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "reinforcement learning agents. CoRR, abs/1705.06366, 2017. URL http://arxiv.org/", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 721, + 205, + 732 + ], + "spans": [ + { + "bbox": [ + 116, + 721, + 205, + 732 + ], + "score": 1.0, + "content": "abs/1705.06366.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 698, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 94 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 94 + ], + "score": 1.0, + "content": "Rein Houthooft, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 117, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 117, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "Curiosity-driven exploration in deep reinforcement learning via bayesian neural networks. arXiv", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 117, + 105, + 194, + 116 + ], + "spans": [ + { + "bbox": [ + 117, + 105, + 194, + 116 + ], + "score": 1.0, + "content": "1605.09674, 2016.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 123, + 503, + 157 + ], + "lines": [ + { + "bbox": [ + 105, + 122, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 105, + 122, + 505, + 136 + ], + "score": 1.0, + "content": "Alexander S. Klyubin, Daniel Polani, and Chrystopher L. Nehaniv. Empowerment: a universal", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 116, + 134, + 505, + 147 + ], + "spans": [ + { + "bbox": [ + 116, + 134, + 505, + 147 + ], + "score": 1.0, + "content": "agent-centric measure of control. In Proceedings of the IEEE Congress on Evolutionary Compu-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 116, + 145, + 249, + 158 + ], + "spans": [ + { + "bbox": [ + 116, + 145, + 249, + 158 + ], + "score": 1.0, + "content": "tation, CEC, pp. 128–135, 2005.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 106, + 163, + 502, + 187 + ], + "lines": [ + { + "bbox": [ + 105, + 163, + 504, + 176 + ], + "spans": [ + { + "bbox": [ + 105, + 163, + 504, + 176 + ], + "score": 1.0, + "content": "M. P. Kumar, Benjamin Packer, and Daphne Koller. Self-paced learning for latent variable models.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 174, + 177, + 186 + ], + "spans": [ + { + "bbox": [ + 115, + 174, + 177, + 186 + ], + "score": 1.0, + "content": "In NIPS. 2010.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 106, + 194, + 503, + 217 + ], + "lines": [ + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "score": 1.0, + "content": "Jiwei Li, Will Monroe, Tianlin Shi, Alan Ritter, and Dan Jurafsky. Adversarial learning for neural", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 116, + 205, + 303, + 218 + ], + "spans": [ + { + "bbox": [ + 116, + 205, + 303, + 218 + ], + "score": 1.0, + "content": "dialogue generation. arXiv 1701.06547, 2017.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 105, + 223, + 503, + 247 + ], + "lines": [ + { + "bbox": [ + 106, + 225, + 505, + 236 + ], + "spans": [ + { + "bbox": [ + 106, + 225, + 505, + 236 + ], + "score": 1.0, + "content": "Manuel Lopes, Tobias Lang, Marc Toussaint, and Pierre-Yves Oudeyer. Exploration in model-based", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 235, + 505, + 248 + ], + "spans": [ + { + "bbox": [ + 115, + 235, + 505, + 248 + ], + "score": 1.0, + "content": "reinforcement learning by empirically estimating learning progress. In NIPS, pp. 206–214, 2012.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 106, + 253, + 503, + 277 + ], + "lines": [ + { + "bbox": [ + 105, + 253, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 505, + 267 + ], + "score": 1.0, + "content": "Lars M. Mescheder, Sebastian Nowozin, and Andreas Geiger. Adversarial variational bayes: Unify-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 265, + 500, + 277 + ], + "spans": [ + { + "bbox": [ + 115, + 265, + 500, + 277 + ], + "score": 1.0, + "content": "ing variational autoencoders and generative adversarial networks. arXiv abs/1701.04722, 2017.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 107, + 283, + 503, + 307 + ], + "lines": [ + { + "bbox": [ + 105, + 282, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 505, + 298 + ], + "score": 1.0, + "content": "Deepak Pathak, Pulkit Agrawal, Alexei A. Efros, and Trevor Darrell. Curiosity-driven exploration", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 295, + 303, + 308 + ], + "spans": [ + { + "bbox": [ + 115, + 295, + 303, + 308 + ], + "score": 1.0, + "content": "by self-supervised prediction. In ICML, 2017.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5 + }, + { + "type": "text", + "bbox": [ + 107, + 314, + 503, + 348 + ], + "lines": [ + { + "bbox": [ + 105, + 314, + 504, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 314, + 504, + 326 + ], + "score": 1.0, + "content": "Lerrel Pinto, James Davidson, Rahul Sukthankar, and Abhinav Gupta. Robust adversarial rein-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 116, + 325, + 504, + 337 + ], + "spans": [ + { + "bbox": [ + 116, + 325, + 504, + 337 + ], + "score": 1.0, + "content": "forcement learning. CoRR, abs/1703.02702, 2017. URL http://arxiv.org/abs/1703.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 116, + 336, + 151, + 348 + ], + "spans": [ + { + "bbox": [ + 116, + 336, + 151, + 348 + ], + "score": 1.0, + "content": "02702.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 106, + 354, + 504, + 378 + ], + "lines": [ + { + "bbox": [ + 106, + 354, + 505, + 367 + ], + "spans": [ + { + "bbox": [ + 106, + 354, + 505, + 367 + ], + "score": 1.0, + "content": "Martin Riedmiller, Thomas Gabel, Roland Hafner, and Sascha Lange. Reinforcement learning for", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 366, + 335, + 378 + ], + "spans": [ + { + "bbox": [ + 116, + 366, + 335, + 378 + ], + "score": 1.0, + "content": "robot soccer. Autonomous Robots, 27(1):55–73, 2009.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 107, + 385, + 505, + 408 + ], + "lines": [ + { + "bbox": [ + 105, + 384, + 506, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 506, + 398 + ], + "score": 1.0, + "content": "Arthur L. Samuel. Some studies in machine learning using the game of checkers. IBM Journal of", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 116, + 396, + 314, + 408 + ], + "spans": [ + { + "bbox": [ + 116, + 396, + 314, + 408 + ], + "score": 1.0, + "content": "Research and Development, 3(3):210–229, 1959.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5 + }, + { + "type": "text", + "bbox": [ + 107, + 414, + 504, + 438 + ], + "lines": [ + { + "bbox": [ + 105, + 414, + 506, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 506, + 428 + ], + "score": 1.0, + "content": "Tom Schaul, Dan Horgan, Karol Gregor, and David Silver. Universal value function approximators.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 425, + 246, + 438 + ], + "spans": [ + { + "bbox": [ + 115, + 425, + 246, + 438 + ], + "score": 1.0, + "content": "In ICML, pp. 1312–1320, 2015.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 106, + 444, + 504, + 468 + ], + "lines": [ + { + "bbox": [ + 105, + 444, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 505, + 457 + ], + "score": 1.0, + "content": "J. Schmidhuber. Curious model-building control systems. In Proc. Int. J. Conf. Neural Networks,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 455, + 257, + 468 + ], + "spans": [ + { + "bbox": [ + 115, + 455, + 257, + 468 + ], + "score": 1.0, + "content": "pp. 1458–1463. IEEE Press, 1991.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 106, + 474, + 504, + 498 + ], + "lines": [ + { + "bbox": [ + 105, + 473, + 505, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 505, + 488 + ], + "score": 1.0, + "content": "John Schulman, Sergey Levine, Philipp Moritz, Michael I. Jordan, and Pieter Abbeel. Trust region", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 486, + 300, + 498 + ], + "spans": [ + { + "bbox": [ + 115, + 486, + 300, + 498 + ], + "score": 1.0, + "content": "policy optimization. arXiv1502.05477, 2015.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 106, + 504, + 506, + 560 + ], + "lines": [ + { + "bbox": [ + 106, + 505, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 505, + 518 + ], + "score": 1.0, + "content": "David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 514, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 115, + 514, + 505, + 529 + ], + "score": 1.0, + "content": "Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, Sander Dieleman,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 525, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 115, + 525, + 505, + 540 + ], + "score": 1.0, + "content": "Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy Lillicrap, Madeleine", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 538, + 506, + 551 + ], + "spans": [ + { + "bbox": [ + 115, + 538, + 506, + 551 + ], + "score": 1.0, + "content": "Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of Go with", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 548, + 445, + 561 + ], + "spans": [ + { + "bbox": [ + 115, + 548, + 445, + 561 + ], + "score": 1.0, + "content": "deep neural networks and tree search. Nature, 529(7587):484–489, January 2016.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 104, + 567, + 504, + 591 + ], + "lines": [ + { + "bbox": [ + 106, + 567, + 504, + 580 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 504, + 580 + ], + "score": 1.0, + "content": "Satinder P. Singh, Andrew G. Barto, and Nuttapong Chentanez. Intrinsically motivated reinforce-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 579, + 304, + 591 + ], + "spans": [ + { + "bbox": [ + 115, + 579, + 304, + 591 + ], + "score": 1.0, + "content": "ment learning. In NIPS, pp. 1281–1288, 2004.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5 + }, + { + "type": "text", + "bbox": [ + 104, + 597, + 504, + 621 + ], + "lines": [ + { + "bbox": [ + 106, + 598, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 598, + 505, + 609 + ], + "score": 1.0, + "content": "Alexander L. Strehl and Michael L. Littman. An analysis of model-based interval estimation for", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 609, + 414, + 621 + ], + "spans": [ + { + "bbox": [ + 115, + 609, + 414, + 621 + ], + "score": 1.0, + "content": "markov decision processes. J. Comput. Syst. Sci., 74(8):1309–1331, 2008.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 104, + 627, + 504, + 651 + ], + "lines": [ + { + "bbox": [ + 106, + 628, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 106, + 628, + 505, + 641 + ], + "score": 1.0, + "content": "Sainbayar Sukhbaatar, Arthur Szlam, Gabriel Synnaeve, Soumith Chintala, and Rob Fergus. Maze-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 639, + 390, + 651 + ], + "spans": [ + { + "bbox": [ + 116, + 639, + 390, + 651 + ], + "score": 1.0, + "content": "base: A sandbox for learning from games. arXiv 1511.07401, 2015.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5 + }, + { + "type": "text", + "bbox": [ + 108, + 657, + 504, + 692 + ], + "lines": [ + { + "bbox": [ + 105, + 657, + 506, + 671 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 506, + 671 + ], + "score": 1.0, + "content": "Richard S. Sutton, Joseph Modayil, Michael Delp, Thomas Degris, Patrick M. Pilarski, Adam White,", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 116, + 669, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 116, + 669, + 505, + 681 + ], + "score": 1.0, + "content": "and Doina Precup. Horde: A scalable real-time architecture for learning knowledge from unsu-", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 680, + 398, + 692 + ], + "spans": [ + { + "bbox": [ + 115, + 680, + 398, + 692 + ], + "score": 1.0, + "content": "pervised sensorimotor interaction. In AAMAS ’11, pp. 761–768, 2011.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 107, + 699, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 697, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 505, + 713 + ], + "score": 1.0, + "content": "Gabriel Synnaeve, Nantas Nardelli, Alex Auvolat, Soumith Chintala, Timothee Lacroix, Zeming ´", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 116, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 116, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "Lin, Florian Richoux, and Nicolas Usunier. Torchcraft: a library for machine learning research", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 116, + 721, + 394, + 733 + ], + "spans": [ + { + "bbox": [ + 116, + 721, + 394, + 733 + ], + "score": 1.0, + "content": "on real-time strategy games. arXiv preprint arXiv:1611.00625, 2016.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published 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": "text", + "bbox": [ + 107, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 94 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 94 + ], + "score": 1.0, + "content": "Rein Houthooft, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 117, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 117, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "Curiosity-driven exploration in deep reinforcement learning via bayesian neural networks. arXiv", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 117, + 105, + 194, + 116 + ], + "spans": [ + { + "bbox": [ + 117, + 105, + 194, + 116 + ], + "score": 1.0, + "content": "1605.09674, 2016.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 105, + 82, + 505, + 116 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 123, + 503, + 157 + ], + "lines": [ + { + "bbox": [ + 105, + 122, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 105, + 122, + 505, + 136 + ], + "score": 1.0, + "content": "Alexander S. Klyubin, Daniel Polani, and Chrystopher L. Nehaniv. Empowerment: a universal", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 116, + 134, + 505, + 147 + ], + "spans": [ + { + "bbox": [ + 116, + 134, + 505, + 147 + ], + "score": 1.0, + "content": "agent-centric measure of control. In Proceedings of the IEEE Congress on Evolutionary Compu-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 116, + 145, + 249, + 158 + ], + "spans": [ + { + "bbox": [ + 116, + 145, + 249, + 158 + ], + "score": 1.0, + "content": "tation, CEC, pp. 128–135, 2005.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4, + "bbox_fs": [ + 105, + 122, + 505, + 158 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 163, + 502, + 187 + ], + "lines": [ + { + "bbox": [ + 105, + 163, + 504, + 176 + ], + "spans": [ + { + "bbox": [ + 105, + 163, + 504, + 176 + ], + "score": 1.0, + "content": "M. P. Kumar, Benjamin Packer, and Daphne Koller. Self-paced learning for latent variable models.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 174, + 177, + 186 + ], + "spans": [ + { + "bbox": [ + 115, + 174, + 177, + 186 + ], + "score": 1.0, + "content": "In NIPS. 2010.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5, + "bbox_fs": [ + 105, + 163, + 504, + 186 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 194, + 503, + 217 + ], + "lines": [ + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "score": 1.0, + "content": "Jiwei Li, Will Monroe, Tianlin Shi, Alan Ritter, and Dan Jurafsky. Adversarial learning for neural", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 116, + 205, + 303, + 218 + ], + "spans": [ + { + "bbox": [ + 116, + 205, + 303, + 218 + ], + "score": 1.0, + "content": "dialogue generation. arXiv 1701.06547, 2017.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5, + "bbox_fs": [ + 106, + 194, + 505, + 218 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 223, + 503, + 247 + ], + "lines": [ + { + "bbox": [ + 106, + 225, + 505, + 236 + ], + "spans": [ + { + "bbox": [ + 106, + 225, + 505, + 236 + ], + "score": 1.0, + "content": "Manuel Lopes, Tobias Lang, Marc Toussaint, and Pierre-Yves Oudeyer. Exploration in model-based", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 235, + 505, + 248 + ], + "spans": [ + { + "bbox": [ + 115, + 235, + 505, + 248 + ], + "score": 1.0, + "content": "reinforcement learning by empirically estimating learning progress. In NIPS, pp. 206–214, 2012.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5, + "bbox_fs": [ + 106, + 225, + 505, + 248 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 253, + 503, + 277 + ], + "lines": [ + { + "bbox": [ + 105, + 253, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 505, + 267 + ], + "score": 1.0, + "content": "Lars M. Mescheder, Sebastian Nowozin, and Andreas Geiger. Adversarial variational bayes: Unify-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 265, + 500, + 277 + ], + "spans": [ + { + "bbox": [ + 115, + 265, + 500, + 277 + ], + "score": 1.0, + "content": "ing variational autoencoders and generative adversarial networks. arXiv abs/1701.04722, 2017.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5, + "bbox_fs": [ + 105, + 253, + 505, + 277 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 283, + 503, + 307 + ], + "lines": [ + { + "bbox": [ + 105, + 282, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 505, + 298 + ], + "score": 1.0, + "content": "Deepak Pathak, Pulkit Agrawal, Alexei A. Efros, and Trevor Darrell. Curiosity-driven exploration", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 295, + 303, + 308 + ], + "spans": [ + { + "bbox": [ + 115, + 295, + 303, + 308 + ], + "score": 1.0, + "content": "by self-supervised prediction. In ICML, 2017.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5, + "bbox_fs": [ + 105, + 282, + 505, + 308 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 314, + 503, + 348 + ], + "lines": [ + { + "bbox": [ + 105, + 314, + 504, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 314, + 504, + 326 + ], + "score": 1.0, + "content": "Lerrel Pinto, James Davidson, Rahul Sukthankar, and Abhinav Gupta. Robust adversarial rein-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 116, + 325, + 504, + 337 + ], + "spans": [ + { + "bbox": [ + 116, + 325, + 504, + 337 + ], + "score": 1.0, + "content": "forcement learning. CoRR, abs/1703.02702, 2017. URL http://arxiv.org/abs/1703.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 116, + 336, + 151, + 348 + ], + "spans": [ + { + "bbox": [ + 116, + 336, + 151, + 348 + ], + "score": 1.0, + "content": "02702.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 314, + 504, + 348 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 354, + 504, + 378 + ], + "lines": [ + { + "bbox": [ + 106, + 354, + 505, + 367 + ], + "spans": [ + { + "bbox": [ + 106, + 354, + 505, + 367 + ], + "score": 1.0, + "content": "Martin Riedmiller, Thomas Gabel, Roland Hafner, and Sascha Lange. Reinforcement learning for", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 366, + 335, + 378 + ], + "spans": [ + { + "bbox": [ + 116, + 366, + 335, + 378 + ], + "score": 1.0, + "content": "robot soccer. Autonomous Robots, 27(1):55–73, 2009.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5, + "bbox_fs": [ + 106, + 354, + 505, + 378 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 385, + 505, + 408 + ], + "lines": [ + { + "bbox": [ + 105, + 384, + 506, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 506, + 398 + ], + "score": 1.0, + "content": "Arthur L. Samuel. Some studies in machine learning using the game of checkers. IBM Journal of", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 116, + 396, + 314, + 408 + ], + "spans": [ + { + "bbox": [ + 116, + 396, + 314, + 408 + ], + "score": 1.0, + "content": "Research and Development, 3(3):210–229, 1959.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 384, + 506, + 408 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 414, + 504, + 438 + ], + "lines": [ + { + "bbox": [ + 105, + 414, + 506, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 506, + 428 + ], + "score": 1.0, + "content": "Tom Schaul, Dan Horgan, Karol Gregor, and David Silver. Universal value function approximators.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 425, + 246, + 438 + ], + "spans": [ + { + "bbox": [ + 115, + 425, + 246, + 438 + ], + "score": 1.0, + "content": "In ICML, pp. 1312–1320, 2015.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 414, + 506, + 438 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 444, + 504, + 468 + ], + "lines": [ + { + "bbox": [ + 105, + 444, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 505, + 457 + ], + "score": 1.0, + "content": "J. Schmidhuber. Curious model-building control systems. In Proc. Int. J. Conf. Neural Networks,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 455, + 257, + 468 + ], + "spans": [ + { + "bbox": [ + 115, + 455, + 257, + 468 + ], + "score": 1.0, + "content": "pp. 1458–1463. IEEE Press, 1991.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5, + "bbox_fs": [ + 105, + 444, + 505, + 468 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 474, + 504, + 498 + ], + "lines": [ + { + "bbox": [ + 105, + 473, + 505, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 505, + 488 + ], + "score": 1.0, + "content": "John Schulman, Sergey Levine, Philipp Moritz, Michael I. Jordan, and Pieter Abbeel. Trust region", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 486, + 300, + 498 + ], + "spans": [ + { + "bbox": [ + 115, + 486, + 300, + 498 + ], + "score": 1.0, + "content": "policy optimization. arXiv1502.05477, 2015.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 473, + 505, + 498 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 504, + 506, + 560 + ], + "lines": [ + { + "bbox": [ + 106, + 505, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 505, + 518 + ], + "score": 1.0, + "content": "David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 514, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 115, + 514, + 505, + 529 + ], + "score": 1.0, + "content": "Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, Sander Dieleman,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 525, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 115, + 525, + 505, + 540 + ], + "score": 1.0, + "content": "Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy Lillicrap, Madeleine", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 538, + 506, + 551 + ], + "spans": [ + { + "bbox": [ + 115, + 538, + 506, + 551 + ], + "score": 1.0, + "content": "Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of Go with", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 548, + 445, + 561 + ], + "spans": [ + { + "bbox": [ + 115, + 548, + 445, + 561 + ], + "score": 1.0, + "content": "deep neural networks and tree search. Nature, 529(7587):484–489, January 2016.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31, + "bbox_fs": [ + 106, + 505, + 506, + 561 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 567, + 504, + 591 + ], + "lines": [ + { + "bbox": [ + 106, + 567, + 504, + 580 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 504, + 580 + ], + "score": 1.0, + "content": "Satinder P. Singh, Andrew G. Barto, and Nuttapong Chentanez. Intrinsically motivated reinforce-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 579, + 304, + 591 + ], + "spans": [ + { + "bbox": [ + 115, + 579, + 304, + 591 + ], + "score": 1.0, + "content": "ment learning. In NIPS, pp. 1281–1288, 2004.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5, + "bbox_fs": [ + 106, + 567, + 504, + 591 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 597, + 504, + 621 + ], + "lines": [ + { + "bbox": [ + 106, + 598, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 598, + 505, + 609 + ], + "score": 1.0, + "content": "Alexander L. Strehl and Michael L. Littman. An analysis of model-based interval estimation for", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 609, + 414, + 621 + ], + "spans": [ + { + "bbox": [ + 115, + 609, + 414, + 621 + ], + "score": 1.0, + "content": "markov decision processes. J. Comput. Syst. Sci., 74(8):1309–1331, 2008.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5, + "bbox_fs": [ + 106, + 598, + 505, + 621 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 627, + 504, + 651 + ], + "lines": [ + { + "bbox": [ + 106, + 628, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 106, + 628, + 505, + 641 + ], + "score": 1.0, + "content": "Sainbayar Sukhbaatar, Arthur Szlam, Gabriel Synnaeve, Soumith Chintala, and Rob Fergus. Maze-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 639, + 390, + 651 + ], + "spans": [ + { + "bbox": [ + 116, + 639, + 390, + 651 + ], + "score": 1.0, + "content": "base: A sandbox for learning from games. arXiv 1511.07401, 2015.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5, + "bbox_fs": [ + 106, + 628, + 505, + 651 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 657, + 504, + 692 + ], + "lines": [ + { + "bbox": [ + 105, + 657, + 506, + 671 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 506, + 671 + ], + "score": 1.0, + "content": "Richard S. Sutton, Joseph Modayil, Michael Delp, Thomas Degris, Patrick M. Pilarski, Adam White,", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 116, + 669, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 116, + 669, + 505, + 681 + ], + "score": 1.0, + "content": "and Doina Precup. Horde: A scalable real-time architecture for learning knowledge from unsu-", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 680, + 398, + 692 + ], + "spans": [ + { + "bbox": [ + 115, + 680, + 398, + 692 + ], + "score": 1.0, + "content": "pervised sensorimotor interaction. In AAMAS ’11, pp. 761–768, 2011.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41, + "bbox_fs": [ + 105, + 657, + 506, + 692 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 699, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 697, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 505, + 713 + ], + "score": 1.0, + "content": "Gabriel Synnaeve, Nantas Nardelli, Alex Auvolat, Soumith Chintala, Timothee Lacroix, Zeming ´", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 116, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 116, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "Lin, Florian Richoux, and Nicolas Usunier. Torchcraft: a library for machine learning research", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 116, + 721, + 394, + 733 + ], + "spans": [ + { + "bbox": [ + 116, + 721, + 394, + 733 + ], + "score": 1.0, + "content": "on real-time strategy games. arXiv preprint arXiv:1611.00625, 2016.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44, + "bbox_fs": [ + 105, + 697, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 94 + ], + "score": 1.0, + "content": "H. Tang, R. Houthooft, D. Foote, A. Stooke, X. Chen, Y. Duan, J. Schulman, F. De Turck, and", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 92, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 115, + 92, + 505, + 107 + ], + "score": 1.0, + "content": "P. Abbeel. #exploration: A study of count-based exploration for deep reinforcement learning.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 104, + 235, + 116 + ], + "spans": [ + { + "bbox": [ + 115, + 104, + 235, + 116 + ], + "score": 1.0, + "content": "arXiv abs/1611.04717, 2016.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 106, + 122, + 504, + 135 + ], + "lines": [ + { + "bbox": [ + 106, + 122, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 106, + 122, + 505, + 136 + ], + "score": 1.0, + "content": "Gerald Tesauro. Temporal difference learning and td-gammon. Commun. ACM, 38(3):58–68, 1995.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 106, + 141, + 504, + 164 + ], + "lines": [ + { + "bbox": [ + 105, + 139, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 105, + 139, + 505, + 155 + ], + "score": 1.0, + "content": "T. Tieleman and G. Hinton. Lecture 6.5 - rmsprop, coursera: Neural networks for machine learning,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 114, + 151, + 143, + 165 + ], + "spans": [ + { + "bbox": [ + 114, + 151, + 143, + 165 + ], + "score": 1.0, + "content": "2012.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 107, + 170, + 503, + 194 + ], + "lines": [ + { + "bbox": [ + 106, + 171, + 505, + 183 + ], + "spans": [ + { + "bbox": [ + 106, + 171, + 505, + 183 + ], + "score": 1.0, + "content": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 182, + 269, + 194 + ], + "spans": [ + { + "bbox": [ + 116, + 182, + 269, + 194 + ], + "score": 1.0, + "content": "In IROS, pp. 5026–5033. IEEE, 2012.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 106, + 200, + 504, + 223 + ], + "lines": [ + { + "bbox": [ + 106, + 200, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 106, + 200, + 505, + 213 + ], + "score": 1.0, + "content": "Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 211, + 325, + 224 + ], + "spans": [ + { + "bbox": [ + 115, + 211, + 325, + 224 + ], + "score": 1.0, + "content": "learning. In Machine Learning, pp. 229–256, 1992.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5 + }, + { + "type": "title", + "bbox": [ + 108, + 243, + 204, + 257 + ], + "lines": [ + { + "bbox": [ + 105, + 241, + 206, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 206, + 259 + ], + "score": 1.0, + "content": "A PSEUDO CODE", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 106, + 268, + 499, + 280 + ], + "lines": [ + { + "bbox": [ + 106, + 267, + 501, + 282 + ], + "spans": [ + { + "bbox": [ + 106, + 267, + 501, + 282 + ], + "score": 1.0, + "content": "Algorithm 1 and 2 are the pseudo codes for training an agent on self-play and target task episodes.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "title", + "bbox": [ + 108, + 292, + 386, + 303 + ], + "lines": [ + { + "bbox": [ + 105, + 290, + 387, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 387, + 306 + ], + "score": 1.0, + "content": "Algorithm 1 Pseudo code for training an agent on a self-play episode", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "table", + "bbox": [ + 105, + 303, + 504, + 591 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 105, + 303, + 504, + 591 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 303, + 504, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 303, + 504, + 591 + ], + "score": 0.844, + "html": "
function SELFPLAYEPISODE(REVERSE/REPEAT,tMAx,0A,0B)
tA↑0 So←env.observe()
S* ↑
while True do
# Alice's turn
tA←tA+1
s ← env.observe()
a←πA(s,so)=f(s,So,0A)
if α = STOP or tA ≥ tMax then
s*↑s env.reset()
break
env.act(a)
tb↑0
while True do
#Bob's turn
s← env.observe()
if s= s*or tA+tb≥tMax then
break
tb←tb+1
a←TB(s,s*)=f(s,s*,0B)
env.act(a)
RA←γmax(O,tB-tA)
RB←-γtB
policy.update(RA, 0A)
policy.update(RB,0B)
return
", + "type": "table", + "image_path": "10da804eb7b8aba25b54aa9cc6f1d6d4fcd5cc0be34d28f04fb28640c08cbe71.jpg" + } + ] + } + ], + "index": 14, + "virtual_lines": [ + { + "bbox": [ + 105, + 303, + 504, + 399.0 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 105, + 399.0, + 504, + 495.0 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 105, + 495.0, + 504, + 591.0 + ], + "spans": [], + "index": 15 + } + ] + } + ], + "index": 14 + }, + { + "type": "title", + "bbox": [ + 107, + 613, + 376, + 625 + ], + "lines": [ + { + "bbox": [ + 105, + 612, + 377, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 377, + 628 + ], + "score": 1.0, + "content": "B HYPERPARAMETERS USED IN THE EXPERIMENTS", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 637, + 505, + 703 + ], + "lines": [ + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 460, + 650 + ], + "score": 1.0, + "content": "For the experiments with neural networks, all parameters are randomly initialized from", + "type": "text" + }, + { + "bbox": [ + 460, + 637, + 501, + 649 + ], + "score": 0.91, + "content": "\\mathcal { N } ( 0 , 0 . 2 )", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 637, + 505, + 650 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 647, + 506, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 647, + 321, + 661 + ], + "score": 1.0, + "content": "The Hyperparameters of RMSProp are set to 0.97 and", + "type": "text" + }, + { + "bbox": [ + 322, + 649, + 348, + 659 + ], + "score": 0.86, + "content": "1 e - 6", + "type": "inline_equation" + }, + { + "bbox": [ + 348, + 647, + 506, + 661 + ], + "score": 1.0, + "content": ". The other hyperparameter values used", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 658, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 505, + 672 + ], + "score": 1.0, + "content": "in the experiments are shown in Table 1. In some cases, we used different parameters for self-play", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 668, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 505, + 684 + ], + "score": 1.0, + "content": "and target task episodes. Entropy regularization is implemented as an additional cost maximizing", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 680, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 505, + 693 + ], + "score": 1.0, + "content": "the entropy of the softmax layer. In the StarCraft, skipping 23 frames roughly matches to one action", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 693, + 154, + 703 + ], + "spans": [ + { + "bbox": [ + 105, + 693, + 154, + 703 + ], + "score": 1.0, + "content": "per second.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 19.5 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 105, + 711, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 118, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 118, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "5Experiments in VIME and SimHash papers skip 50 frames, but we matched the total number of frames in", + "type": "text" + } + ] + }, + { + "bbox": [ + 105, + 721, + 267, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 267, + 733 + ], + "score": 1.0, + "content": "an episode by reducing the number of steps.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "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 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 94 + ], + "score": 1.0, + "content": "H. Tang, R. Houthooft, D. Foote, A. Stooke, X. Chen, Y. Duan, J. Schulman, F. De Turck, and", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 92, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 115, + 92, + 505, + 107 + ], + "score": 1.0, + "content": "P. Abbeel. #exploration: A study of count-based exploration for deep reinforcement learning.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 104, + 235, + 116 + ], + "spans": [ + { + "bbox": [ + 115, + 104, + 235, + 116 + ], + "score": 1.0, + "content": "arXiv abs/1611.04717, 2016.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 106, + 82, + 505, + 116 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 122, + 504, + 135 + ], + "lines": [ + { + "bbox": [ + 106, + 122, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 106, + 122, + 505, + 136 + ], + "score": 1.0, + "content": "Gerald Tesauro. Temporal difference learning and td-gammon. Commun. ACM, 38(3):58–68, 1995.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3, + "bbox_fs": [ + 106, + 122, + 505, + 136 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 141, + 504, + 164 + ], + "lines": [ + { + "bbox": [ + 105, + 139, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 105, + 139, + 505, + 155 + ], + "score": 1.0, + "content": "T. Tieleman and G. Hinton. Lecture 6.5 - rmsprop, coursera: Neural networks for machine learning,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 114, + 151, + 143, + 165 + ], + "spans": [ + { + "bbox": [ + 114, + 151, + 143, + 165 + ], + "score": 1.0, + "content": "2012.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5, + "bbox_fs": [ + 105, + 139, + 505, + 165 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 170, + 503, + 194 + ], + "lines": [ + { + "bbox": [ + 106, + 171, + 505, + 183 + ], + "spans": [ + { + "bbox": [ + 106, + 171, + 505, + 183 + ], + "score": 1.0, + "content": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 182, + 269, + 194 + ], + "spans": [ + { + "bbox": [ + 116, + 182, + 269, + 194 + ], + "score": 1.0, + "content": "In IROS, pp. 5026–5033. IEEE, 2012.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5, + "bbox_fs": [ + 106, + 171, + 505, + 194 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 200, + 504, + 223 + ], + "lines": [ + { + "bbox": [ + 106, + 200, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 106, + 200, + 505, + 213 + ], + "score": 1.0, + "content": "Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 211, + 325, + 224 + ], + "spans": [ + { + "bbox": [ + 115, + 211, + 325, + 224 + ], + "score": 1.0, + "content": "learning. In Machine Learning, pp. 229–256, 1992.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5, + "bbox_fs": [ + 106, + 200, + 505, + 224 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 243, + 204, + 257 + ], + "lines": [ + { + "bbox": [ + 105, + 241, + 206, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 206, + 259 + ], + "score": 1.0, + "content": "A PSEUDO CODE", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 106, + 268, + 499, + 280 + ], + "lines": [ + { + "bbox": [ + 106, + 267, + 501, + 282 + ], + "spans": [ + { + "bbox": [ + 106, + 267, + 501, + 282 + ], + "score": 1.0, + "content": "Algorithm 1 and 2 are the pseudo codes for training an agent on self-play and target task episodes.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11, + "bbox_fs": [ + 106, + 267, + 501, + 282 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 292, + 386, + 303 + ], + "lines": [ + { + "bbox": [ + 105, + 290, + 387, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 387, + 306 + ], + "score": 1.0, + "content": "Algorithm 1 Pseudo code for training an agent on a self-play episode", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "table", + "bbox": [ + 105, + 303, + 504, + 591 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 105, + 303, + 504, + 591 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 303, + 504, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 303, + 504, + 591 + ], + "score": 0.844, + "html": "
function SELFPLAYEPISODE(REVERSE/REPEAT,tMAx,0A,0B)
tA↑0 So←env.observe()
S* ↑
while True do
# Alice's turn
tA←tA+1
s ← env.observe()
a←πA(s,so)=f(s,So,0A)
if α = STOP or tA ≥ tMax then
s*↑s env.reset()
break
env.act(a)
tb↑0
while True do
#Bob's turn
s← env.observe()
if s= s*or tA+tb≥tMax then
break
tb←tb+1
a←TB(s,s*)=f(s,s*,0B)
env.act(a)
RA←γmax(O,tB-tA)
RB←-γtB
policy.update(RA, 0A)
policy.update(RB,0B)
return
", + "type": "table", + "image_path": "10da804eb7b8aba25b54aa9cc6f1d6d4fcd5cc0be34d28f04fb28640c08cbe71.jpg" + } + ] + } + ], + "index": 14, + "virtual_lines": [ + { + "bbox": [ + 105, + 303, + 504, + 399.0 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 105, + 399.0, + 504, + 495.0 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 105, + 495.0, + 504, + 591.0 + ], + "spans": [], + "index": 15 + } + ] + } + ], + "index": 14 + }, + { + "type": "title", + "bbox": [ + 107, + 613, + 376, + 625 + ], + "lines": [ + { + "bbox": [ + 105, + 612, + 377, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 377, + 628 + ], + "score": 1.0, + "content": "B HYPERPARAMETERS USED IN THE EXPERIMENTS", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 637, + 505, + 703 + ], + "lines": [ + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 460, + 650 + ], + "score": 1.0, + "content": "For the experiments with neural networks, all parameters are randomly initialized from", + "type": "text" + }, + { + "bbox": [ + 460, + 637, + 501, + 649 + ], + "score": 0.91, + "content": "\\mathcal { N } ( 0 , 0 . 2 )", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 637, + 505, + 650 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 647, + 506, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 647, + 321, + 661 + ], + "score": 1.0, + "content": "The Hyperparameters of RMSProp are set to 0.97 and", + "type": "text" + }, + { + "bbox": [ + 322, + 649, + 348, + 659 + ], + "score": 0.86, + "content": "1 e - 6", + "type": "inline_equation" + }, + { + "bbox": [ + 348, + 647, + 506, + 661 + ], + "score": 1.0, + "content": ". The other hyperparameter values used", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 658, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 505, + 672 + ], + "score": 1.0, + "content": "in the experiments are shown in Table 1. In some cases, we used different parameters for self-play", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 668, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 505, + 684 + ], + "score": 1.0, + "content": "and target task episodes. Entropy regularization is implemented as an additional cost maximizing", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 680, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 505, + 693 + ], + "score": 1.0, + "content": "the entropy of the softmax layer. In the StarCraft, skipping 23 frames roughly matches to one action", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 693, + 154, + 703 + ], + "spans": [ + { + "bbox": [ + 105, + 693, + 154, + 703 + ], + "score": 1.0, + "content": "per second.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 637, + 506, + 703 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 82, + 392, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 393, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 393, + 96 + ], + "score": 1.0, + "content": "Algorithm 2 Pseudo code for training an agent on a target task episode", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 106, + 88, + 277, + 229 + ], + "lines": [ + { + "bbox": [ + 116, + 95, + 277, + 107 + ], + "spans": [ + { + "bbox": [ + 116, + 95, + 277, + 107 + ], + "score": 1.0, + "content": "function TARGETTASKEPISODE(tMAX, θB)", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 127, + 105, + 156, + 115 + ], + "spans": [ + { + "bbox": [ + 127, + 105, + 156, + 115 + ], + "score": 1.0, + "content": "t ← 0", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 130, + 115, + 159, + 126 + ], + "spans": [ + { + "bbox": [ + 130, + 115, + 159, + 126 + ], + "score": 1.0, + "content": "R ← 0", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 129, + 126, + 183, + 136 + ], + "spans": [ + { + "bbox": [ + 129, + 126, + 183, + 136 + ], + "score": 1.0, + "content": "while True do", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 143, + 136, + 182, + 145 + ], + "spans": [ + { + "bbox": [ + 143, + 136, + 182, + 145 + ], + "score": 0.46, + "content": "t \\gets t + 1", + "type": "inline_equation", + "image_path": "8123311a4182aeccae39829c68d57942d83735ab0fc37b067c8e35bbfc07b759.jpg" + } + ], + "index": 5 + }, + { + "bbox": [ + 144, + 146, + 212, + 156 + ], + "spans": [ + { + "bbox": [ + 144, + 147, + 161, + 155 + ], + "score": 0.48, + "content": "s ", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 146, + 212, + 156 + ], + "score": 1.0, + "content": "env.observe()", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 144, + 155, + 248, + 166 + ], + "spans": [ + { + "bbox": [ + 144, + 155, + 248, + 166 + ], + "score": 0.75, + "content": "a \\pi _ { B } ( s , \\emptyset ) = f ( s , \\emptyset , \\theta _ { B } )", + "type": "inline_equation" + } + ], + "index": 7 + }, + { + "bbox": [ + 142, + 164, + 254, + 177 + ], + "spans": [ + { + "bbox": [ + 142, + 164, + 201, + 177 + ], + "score": 1.0, + "content": "if env.done() or", + "type": "text" + }, + { + "bbox": [ + 201, + 167, + 233, + 176 + ], + "score": 0.8, + "content": "t \\geq t _ { \\mathrm { M a x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 164, + 254, + 177 + ], + "score": 1.0, + "content": "then", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 155, + 175, + 182, + 186 + ], + "spans": [ + { + "bbox": [ + 155, + 175, + 182, + 186 + ], + "score": 1.0, + "content": "break", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 143, + 185, + 182, + 197 + ], + "spans": [ + { + "bbox": [ + 143, + 185, + 182, + 197 + ], + "score": 1.0, + "content": "env.act(a)", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 144, + 194, + 226, + 207 + ], + "spans": [ + { + "bbox": [ + 144, + 196, + 178, + 205 + ], + "score": 0.85, + "content": "R = R +", + "type": "inline_equation" + }, + { + "bbox": [ + 179, + 194, + 226, + 207 + ], + "score": 1.0, + "content": "env.reward()", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 129, + 207, + 207, + 218 + ], + "spans": [ + { + "bbox": [ + 129, + 207, + 178, + 218 + ], + "score": 1.0, + "content": "policy.update", + "type": "text" + }, + { + "bbox": [ + 178, + 207, + 207, + 218 + ], + "score": 0.72, + "content": "( R , \\theta _ { B } )", + "type": "inline_equation" + } + ], + "index": 12 + }, + { + "bbox": [ + 129, + 217, + 157, + 228 + ], + "spans": [ + { + "bbox": [ + 129, + 217, + 157, + 228 + ], + "score": 1.0, + "content": "return", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 7 + }, + { + "type": "table", + "bbox": [ + 120, + 241, + 490, + 380 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 120, + 241, + 490, + 380 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 120, + 241, + 490, + 380 + ], + "spans": [ + { + "bbox": [ + 120, + 241, + 490, + 380 + ], + "score": 0.982, + "html": "
HyperparameternameLongHallwayMazebaseMountainCarSwimmerGatherStarCraft
Learning rate0.10.0030.0030.0030.003
Batch size1625612825632
Max steps ofepisode (tmax)3080500TT: 166SP: 200200
Entropyregularization00.0030.003TT: 0SP: 0.003TT: 0SP: 0.003
Self-play reward scale (γ)0.0330.10.010.010.01
Self-play percentage-20%1%10%10%
Self-play modeReverseBothRepeatReverseRepeat
Frame skip000150523
", + "type": "table", + "image_path": "18b7d67809c881afc72e3e33a341668ed1c5470680a303c2afa6363f1671be21.jpg" + } + ] + } + ], + "index": 15, + "virtual_lines": [ + { + "bbox": [ + 120, + 241, + 490, + 287.3333333333333 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 120, + 287.3333333333333, + 490, + 333.66666666666663 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 120, + 333.66666666666663, + 490, + 379.99999999999994 + ], + "spans": [], + "index": 16 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 139, + 389, + 471, + 401 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 137, + 386, + 473, + 404 + ], + "spans": [ + { + "bbox": [ + 137, + 386, + 354, + 404 + ], + "score": 1.0, + "content": "Table 1: Hyperparameter values used in experiments.", + "type": "text" + }, + { + "bbox": [ + 354, + 389, + 374, + 399 + ], + "score": 0.37, + "content": "\\mathrm { T T } { = }", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 386, + 418, + 404 + ], + "score": 1.0, + "content": "target task,", + "type": "text" + }, + { + "bbox": [ + 418, + 389, + 437, + 399 + ], + "score": 0.69, + "content": "\\mathrm { S P = }", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 386, + 473, + 404 + ], + "score": 1.0, + "content": "self-play", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + } + ], + "index": 16.0 + }, + { + "type": "title", + "bbox": [ + 106, + 421, + 187, + 434 + ], + "lines": [ + { + "bbox": [ + 105, + 418, + 189, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 418, + 189, + 436 + ], + "score": 1.0, + "content": "C MAZEBASE", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 446, + 504, + 490 + ], + "lines": [ + { + "bbox": [ + 105, + 445, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 506, + 459 + ], + "score": 1.0, + "content": "The agent has full visibility of the maze when the light is on. If light is off, the agent can only see", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 457, + 506, + 469 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 506, + 469 + ], + "score": 1.0, + "content": "the light switch. In self-play, Bob does not need to worry about things that are invisible to him. For", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 469, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 106, + 469, + 505, + 480 + ], + "score": 1.0, + "content": "example, if Alice started with light “off” in reverse self-play, Bob does not need to match the state", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 479, + 385, + 491 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 385, + 491 + ], + "score": 1.0, + "content": "of the door, because it would be invisible to him when the light is off.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 107, + 496, + 505, + 541 + ], + "lines": [ + { + "bbox": [ + 105, + 496, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 496, + 505, + 509 + ], + "score": 1.0, + "content": "In the target task, the agent and the goal are always placed on opposite sides of the wall. Also, the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 507, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 505, + 519 + ], + "score": 1.0, + "content": "light and key switches are placed on the same side as the agent, but the light is always off and the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 518, + 505, + 531 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 505, + 531 + ], + "score": 1.0, + "content": "door is closed initially. Therefore, in order to succeed, the agent has to turn on the light, toggle the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 528, + 380, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 380, + 543 + ], + "score": 1.0, + "content": "key switch to open the door, pass through it, and reach the goal flag.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 107, + 546, + 505, + 601 + ], + "lines": [ + { + "bbox": [ + 105, + 546, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 505, + 558 + ], + "score": 1.0, + "content": "Both Alice and Bob’s policies are modeled by a fully-connected neural network with two hidden", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 557, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 557, + 505, + 569 + ], + "score": 1.0, + "content": "layers each with 100 and 50 units (with tanh non-linearities) respectively. The encoder into each", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 567, + 505, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 505, + 580 + ], + "score": 1.0, + "content": "of the networks takes a bag of words over (objects, locations); that is, there is a separate word in", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 578, + 505, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 505, + 592 + ], + "score": 1.0, + "content": "the lookup table for each (object, location) pair. Action probabilities are output by a linear layer", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 589, + 200, + 602 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 200, + 602 + ], + "score": 1.0, + "content": "followed by a softmax.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29 + }, + { + "type": "title", + "bbox": [ + 108, + 615, + 293, + 626 + ], + "lines": [ + { + "bbox": [ + 106, + 615, + 295, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 295, + 628 + ], + "score": 1.0, + "content": "C.1 BIASING FOR OR AGAINST SELF-PLAY", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 636, + 505, + 703 + ], + "lines": [ + { + "bbox": [ + 106, + 635, + 506, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 506, + 649 + ], + "score": 1.0, + "content": "The effectiveness of our approach depends in part on the similarity between the self-play and target", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 647, + 505, + 659 + ], + "spans": [ + { + "bbox": [ + 106, + 647, + 505, + 659 + ], + "score": 1.0, + "content": "tasks. One way to explore this in our environment is to vary the probability of the light being off", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 657, + 506, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 506, + 670 + ], + "score": 1.0, + "content": "initially during self-play episodes6. Note that the light is always off in the target task; if the light", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 669, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 669, + 505, + 681 + ], + "score": 1.0, + "content": "is usually on at the start of Alice’s turn in reverse, for example, she will learn to turn it off, and", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 679, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 106, + 679, + 505, + 691 + ], + "score": 1.0, + "content": "then Bob will be biased to turn it back on. On the other hand, if the light is usually off at the start", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 690, + 506, + 703 + ], + "spans": [ + { + "bbox": [ + 105, + 690, + 506, + 703 + ], + "score": 1.0, + "content": "of Alice’s turn in reverse, Bob is strongly biased against turning the light on, and so the test task", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 35.5 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 712, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 118, + 708, + 506, + 725 + ], + "spans": [ + { + "bbox": [ + 118, + 708, + 506, + 725 + ], + "score": 1.0, + "content": "6The initial state of the light should dramatically change the behavior of the agent: if it is on then agent can", + "type": "text" + } + ] + }, + { + "bbox": [ + 106, + 720, + 207, + 734 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 207, + 734 + ], + "score": 1.0, + "content": "directly proceed to the key.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published 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": "title", + "bbox": [ + 107, + 82, + 392, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 393, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 393, + 96 + ], + "score": 1.0, + "content": "Algorithm 2 Pseudo code for training an agent on a target task episode", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 106, + 88, + 277, + 229 + ], + "lines": [ + { + "bbox": [ + 116, + 95, + 277, + 107 + ], + "spans": [ + { + "bbox": [ + 116, + 95, + 277, + 107 + ], + "score": 1.0, + "content": "function TARGETTASKEPISODE(tMAX, θB)", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 127, + 105, + 156, + 115 + ], + "spans": [ + { + "bbox": [ + 127, + 105, + 156, + 115 + ], + "score": 1.0, + "content": "t ← 0", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 130, + 115, + 159, + 126 + ], + "spans": [ + { + "bbox": [ + 130, + 115, + 159, + 126 + ], + "score": 1.0, + "content": "R ← 0", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 129, + 126, + 183, + 136 + ], + "spans": [ + { + "bbox": [ + 129, + 126, + 183, + 136 + ], + "score": 1.0, + "content": "while True do", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 143, + 136, + 182, + 145 + ], + "spans": [ + { + "bbox": [ + 143, + 136, + 182, + 145 + ], + "score": 0.46, + "content": "t \\gets t + 1", + "type": "inline_equation", + "image_path": "8123311a4182aeccae39829c68d57942d83735ab0fc37b067c8e35bbfc07b759.jpg" + } + ], + "index": 5 + }, + { + "bbox": [ + 144, + 146, + 212, + 156 + ], + "spans": [ + { + "bbox": [ + 144, + 147, + 161, + 155 + ], + "score": 0.48, + "content": "s ", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 146, + 212, + 156 + ], + "score": 1.0, + "content": "env.observe()", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 144, + 155, + 248, + 166 + ], + "spans": [ + { + "bbox": [ + 144, + 155, + 248, + 166 + ], + "score": 0.75, + "content": "a \\pi _ { B } ( s , \\emptyset ) = f ( s , \\emptyset , \\theta _ { B } )", + "type": "inline_equation" + } + ], + "index": 7 + }, + { + "bbox": [ + 142, + 164, + 254, + 177 + ], + "spans": [ + { + "bbox": [ + 142, + 164, + 201, + 177 + ], + "score": 1.0, + "content": "if env.done() or", + "type": "text" + }, + { + "bbox": [ + 201, + 167, + 233, + 176 + ], + "score": 0.8, + "content": "t \\geq t _ { \\mathrm { M a x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 164, + 254, + 177 + ], + "score": 1.0, + "content": "then", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 155, + 175, + 182, + 186 + ], + "spans": [ + { + "bbox": [ + 155, + 175, + 182, + 186 + ], + "score": 1.0, + "content": "break", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 143, + 185, + 182, + 197 + ], + "spans": [ + { + "bbox": [ + 143, + 185, + 182, + 197 + ], + "score": 1.0, + "content": "env.act(a)", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 144, + 194, + 226, + 207 + ], + "spans": [ + { + "bbox": [ + 144, + 196, + 178, + 205 + ], + "score": 0.85, + "content": "R = R +", + "type": "inline_equation" + }, + { + "bbox": [ + 179, + 194, + 226, + 207 + ], + "score": 1.0, + "content": "env.reward()", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 129, + 207, + 207, + 218 + ], + "spans": [ + { + "bbox": [ + 129, + 207, + 178, + 218 + ], + "score": 1.0, + "content": "policy.update", + "type": "text" + }, + { + "bbox": [ + 178, + 207, + 207, + 218 + ], + "score": 0.72, + "content": "( R , \\theta _ { B } )", + "type": "inline_equation" + } + ], + "index": 12 + }, + { + "bbox": [ + 129, + 217, + 157, + 228 + ], + "spans": [ + { + "bbox": [ + 129, + 217, + 157, + 228 + ], + "score": 1.0, + "content": "return", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 7, + "bbox_fs": [ + 116, + 95, + 277, + 228 + ] + }, + { + "type": "table", + "bbox": [ + 120, + 241, + 490, + 380 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 120, + 241, + 490, + 380 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 120, + 241, + 490, + 380 + ], + "spans": [ + { + "bbox": [ + 120, + 241, + 490, + 380 + ], + "score": 0.982, + "html": "
HyperparameternameLongHallwayMazebaseMountainCarSwimmerGatherStarCraft
Learning rate0.10.0030.0030.0030.003
Batch size1625612825632
Max steps ofepisode (tmax)3080500TT: 166SP: 200200
Entropyregularization00.0030.003TT: 0SP: 0.003TT: 0SP: 0.003
Self-play reward scale (γ)0.0330.10.010.010.01
Self-play percentage-20%1%10%10%
Self-play modeReverseBothRepeatReverseRepeat
Frame skip000150523
", + "type": "table", + "image_path": "18b7d67809c881afc72e3e33a341668ed1c5470680a303c2afa6363f1671be21.jpg" + } + ] + } + ], + "index": 15, + "virtual_lines": [ + { + "bbox": [ + 120, + 241, + 490, + 287.3333333333333 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 120, + 287.3333333333333, + 490, + 333.66666666666663 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 120, + 333.66666666666663, + 490, + 379.99999999999994 + ], + "spans": [], + "index": 16 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 139, + 389, + 471, + 401 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 137, + 386, + 473, + 404 + ], + "spans": [ + { + "bbox": [ + 137, + 386, + 354, + 404 + ], + "score": 1.0, + "content": "Table 1: Hyperparameter values used in experiments.", + "type": "text" + }, + { + "bbox": [ + 354, + 389, + 374, + 399 + ], + "score": 0.37, + "content": "\\mathrm { T T } { = }", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 386, + 418, + 404 + ], + "score": 1.0, + "content": "target task,", + "type": "text" + }, + { + "bbox": [ + 418, + 389, + 437, + 399 + ], + "score": 0.69, + "content": "\\mathrm { S P = }", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 386, + 473, + 404 + ], + "score": 1.0, + "content": "self-play", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + } + ], + "index": 16.0 + }, + { + "type": "title", + "bbox": [ + 106, + 421, + 187, + 434 + ], + "lines": [ + { + "bbox": [ + 105, + 418, + 189, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 418, + 189, + 436 + ], + "score": 1.0, + "content": "C MAZEBASE", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 446, + 504, + 490 + ], + "lines": [ + { + "bbox": [ + 105, + 445, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 506, + 459 + ], + "score": 1.0, + "content": "The agent has full visibility of the maze when the light is on. If light is off, the agent can only see", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 457, + 506, + 469 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 506, + 469 + ], + "score": 1.0, + "content": "the light switch. In self-play, Bob does not need to worry about things that are invisible to him. For", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 469, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 106, + 469, + 505, + 480 + ], + "score": 1.0, + "content": "example, if Alice started with light “off” in reverse self-play, Bob does not need to match the state", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 479, + 385, + 491 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 385, + 491 + ], + "score": 1.0, + "content": "of the door, because it would be invisible to him when the light is off.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5, + "bbox_fs": [ + 105, + 445, + 506, + 491 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 496, + 505, + 541 + ], + "lines": [ + { + "bbox": [ + 105, + 496, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 496, + 505, + 509 + ], + "score": 1.0, + "content": "In the target task, the agent and the goal are always placed on opposite sides of the wall. Also, the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 507, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 505, + 519 + ], + "score": 1.0, + "content": "light and key switches are placed on the same side as the agent, but the light is always off and the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 518, + 505, + 531 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 505, + 531 + ], + "score": 1.0, + "content": "door is closed initially. Therefore, in order to succeed, the agent has to turn on the light, toggle the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 528, + 380, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 380, + 543 + ], + "score": 1.0, + "content": "key switch to open the door, pass through it, and reach the goal flag.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 24.5, + "bbox_fs": [ + 105, + 496, + 505, + 543 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 546, + 505, + 601 + ], + "lines": [ + { + "bbox": [ + 105, + 546, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 505, + 558 + ], + "score": 1.0, + "content": "Both Alice and Bob’s policies are modeled by a fully-connected neural network with two hidden", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 557, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 557, + 505, + 569 + ], + "score": 1.0, + "content": "layers each with 100 and 50 units (with tanh non-linearities) respectively. The encoder into each", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 567, + 505, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 505, + 580 + ], + "score": 1.0, + "content": "of the networks takes a bag of words over (objects, locations); that is, there is a separate word in", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 578, + 505, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 505, + 592 + ], + "score": 1.0, + "content": "the lookup table for each (object, location) pair. Action probabilities are output by a linear layer", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 589, + 200, + 602 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 200, + 602 + ], + "score": 1.0, + "content": "followed by a softmax.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29, + "bbox_fs": [ + 105, + 546, + 505, + 602 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 615, + 293, + 626 + ], + "lines": [ + { + "bbox": [ + 106, + 615, + 295, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 295, + 628 + ], + "score": 1.0, + "content": "C.1 BIASING FOR OR AGAINST SELF-PLAY", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 636, + 505, + 703 + ], + "lines": [ + { + "bbox": [ + 106, + 635, + 506, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 506, + 649 + ], + "score": 1.0, + "content": "The effectiveness of our approach depends in part on the similarity between the self-play and target", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 647, + 505, + 659 + ], + "spans": [ + { + "bbox": [ + 106, + 647, + 505, + 659 + ], + "score": 1.0, + "content": "tasks. One way to explore this in our environment is to vary the probability of the light being off", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 657, + 506, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 506, + 670 + ], + "score": 1.0, + "content": "initially during self-play episodes6. Note that the light is always off in the target task; if the light", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 669, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 669, + 505, + 681 + ], + "score": 1.0, + "content": "is usually on at the start of Alice’s turn in reverse, for example, she will learn to turn it off, and", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 679, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 106, + 679, + 505, + 691 + ], + "score": 1.0, + "content": "then Bob will be biased to turn it back on. On the other hand, if the light is usually off at the start", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 690, + 506, + 703 + ], + "spans": [ + { + "bbox": [ + 105, + 690, + 506, + 703 + ], + "score": 1.0, + "content": "of Alice’s turn in reverse, Bob is strongly biased against turning the light on, and so the test task", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "becomes especially hard. Thus changing this probability gives us some way to adjust the similarity", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 199, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 199, + 105 + ], + "score": 1.0, + "content": "between the two tasks.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 635, + 506, + 703 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "becomes especially hard. Thus changing this probability gives us some way to adjust the similarity", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 199, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 199, + 105 + ], + "score": 1.0, + "content": "between the two tasks.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 106, + 110, + 505, + 177 + ], + "lines": [ + { + "bbox": [ + 106, + 110, + 505, + 123 + ], + "spans": [ + { + "bbox": [ + 106, + 110, + 318, + 123 + ], + "score": 1.0, + "content": "Fig. 6 (left) shows what happens when p(Light off)", + "type": "text" + }, + { + "bbox": [ + 318, + 111, + 338, + 121 + ], + "score": 0.46, + "content": "\\scriptstyle 1 = 0 . 3", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 110, + 505, + 123 + ], + "score": 1.0, + "content": ". Here reverse self-play works well, but", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 104, + 121, + 506, + 134 + ], + "spans": [ + { + "bbox": [ + 104, + 121, + 506, + 134 + ], + "score": 1.0, + "content": "repeat self-play does poorly. As discussed above, this flipping, relative to the previous experiment,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 131, + 505, + 146 + ], + "spans": [ + { + "bbox": [ + 105, + 131, + 505, + 146 + ], + "score": 1.0, + "content": "can be explained as follows: low p(Light off) means that Bob’s task in reverse self-play will typically", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 144, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 106, + 144, + 505, + 155 + ], + "score": 1.0, + "content": "involve returning the light to the on position (irrespective of how Alice left it), the same function", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "score": 1.0, + "content": "that must be performed in the target task. The opposite situation applies for repeat self-play, where", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 164, + 469, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 469, + 178 + ], + "score": 1.0, + "content": "Bob needs to encounter the light typically in the off position to help him with the test task.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 107, + 182, + 505, + 226 + ], + "lines": [ + { + "bbox": [ + 105, + 182, + 505, + 195 + ], + "spans": [ + { + "bbox": [ + 105, + 182, + 505, + 195 + ], + "score": 1.0, + "content": "In Fig. 6 (right) we systematically vary p(Light off) between 0.1 and 0.9. The y-axis shows the", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 193, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 505, + 206 + ], + "score": 1.0, + "content": "speed-up (reduction in target task episodes) relative to training purely on the target-task for runs", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 204, + 505, + 217 + ], + "spans": [ + { + "bbox": [ + 105, + 204, + 505, + 217 + ], + "score": 1.0, + "content": "where the reward goes above -2. Unsuccessful runs are given a unity speed-up factor. The curves", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 216, + 480, + 227 + ], + "spans": [ + { + "bbox": [ + 106, + 216, + 480, + 227 + ], + "score": 1.0, + "content": "show that when the self-play task is not biased against the target task it can help significantly.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9.5 + }, + { + "type": "image", + "bbox": [ + 136, + 237, + 474, + 370 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 136, + 237, + 474, + 370 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 136, + 237, + 474, + 370 + ], + "spans": [ + { + "bbox": [ + 136, + 237, + 474, + 370 + ], + "score": 0.969, + "type": "image", + "image_path": "9dea24e2b8a3722d9cd26042796350f4c072933e9ae2a56930497eb412a13080.jpg" + } + ] + } + ], + "index": 13, + "virtual_lines": [ + { + "bbox": [ + 136, + 237, + 474, + 281.3333333333333 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 136, + 281.3333333333333, + 474, + 325.66666666666663 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 136, + 325.66666666666663, + 474, + 369.99999999999994 + ], + "spans": [], + "index": 14 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 379, + 505, + 478 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 378, + 506, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 506, + 392 + ], + "score": 1.0, + "content": "Figure 6: Left: The performance of self-play when p(Light off) set to 0.3. Here the reverse form", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 390, + 505, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 505, + 402 + ], + "score": 1.0, + "content": "of self-play works well (more details in the text). Right: Reduction in target task episodes relative", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 401, + 506, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 506, + 414 + ], + "score": 1.0, + "content": "to training purely on the target-task as the distance between self-play and the target task varies (for", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 411, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 505, + 425 + ], + "score": 1.0, + "content": "runs where the reward goes above -2 on the Mazebase task – unsuccessful runs are given a unity", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 423, + 506, + 435 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 198, + 435 + ], + "score": 1.0, + "content": "speed-up factor). The", + "type": "text" + }, + { + "bbox": [ + 199, + 425, + 206, + 435 + ], + "score": 0.79, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 206, + 423, + 307, + 435 + ], + "score": 1.0, + "content": "axis is the speedup, and", + "type": "text" + }, + { + "bbox": [ + 308, + 425, + 315, + 433 + ], + "score": 0.75, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 423, + 506, + 435 + ], + "score": 1.0, + "content": "axis is p(Light off). For reverse self-play, the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 434, + 505, + 446 + ], + "spans": [ + { + "bbox": [ + 106, + 434, + 505, + 446 + ], + "score": 1.0, + "content": "low p(Light off) corresponds to having self-play and target tasks be similar to one another, while", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 445, + 506, + 458 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 506, + 458 + ], + "score": 1.0, + "content": "the opposite applies to repeat self-play. For both forms, significant speedups are achieved when", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 456, + 505, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 505, + 469 + ], + "score": 1.0, + "content": "self-play is similar to the target tasks, but the effect diminishes when self-play is biased against the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 467, + 153, + 480 + ], + "spans": [ + { + "bbox": [ + 104, + 467, + 153, + 480 + ], + "score": 1.0, + "content": "target task.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 19 + } + ], + "index": 16.0 + }, + { + "type": "title", + "bbox": [ + 108, + 504, + 295, + 517 + ], + "lines": [ + { + "bbox": [ + 105, + 503, + 297, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 503, + 297, + 519 + ], + "score": 1.0, + "content": "D SWIMMERGATHER EXPERIMENT", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 529, + 505, + 573 + ], + "lines": [ + { + "bbox": [ + 104, + 528, + 506, + 542 + ], + "spans": [ + { + "bbox": [ + 104, + 528, + 506, + 542 + ], + "score": 1.0, + "content": "In Fig. 7 shows details of a single training run. The changes in Alice’s behavior, observed in Fig. 7(c)", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 540, + 506, + 553 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 553 + ], + "score": 1.0, + "content": "and (d), correlate with Alice and Bob’s reward (Fig. 7(b)) and, initially at least, to the reward on the", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 551, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 505, + 563 + ], + "score": 1.0, + "content": "test target (Fig. 7(a)). In Fig. 8 we visualize for a single training run the locations where Alice hands", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 563, + 423, + 574 + ], + "spans": [ + { + "bbox": [ + 106, + 563, + 423, + 574 + ], + "score": 1.0, + "content": "over to Bob at different stages of training, showing how the distribution varies.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5 + }, + { + "type": "image", + "bbox": [ + 107, + 583, + 503, + 661 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 583, + 503, + 661 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 107, + 583, + 503, + 661 + ], + "spans": [ + { + "bbox": [ + 107, + 583, + 503, + 661 + ], + "score": 0.962, + "type": "image", + "image_path": "b10cab091594486bf3cd8e30bf5f5e097c7495e15a6c3fc55af13e6bba396f50.jpg" + } + ] + } + ], + "index": 30, + "virtual_lines": [ + { + "bbox": [ + 107, + 583, + 503, + 609.0 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 107, + 609.0, + 503, + 635.0 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 107, + 635.0, + 503, + 661.0 + ], + "spans": [], + "index": 31 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 660, + 504, + 693 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 659, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 506, + 672 + ], + "score": 1.0, + "content": "Figure 7: A single SwimmerGather training run. (a): Rewards on target task. (b): Rewards from", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "score": 1.0, + "content": "reversible self-play. (c): The number of actions taken by Alice. (d): Distance that Alice travels", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 682, + 207, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 207, + 694 + ], + "score": 1.0, + "content": "before switching to Bob.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33 + } + ], + "index": 31.5 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "In the TRPO experiment, we used step size 0.01 and damping coefficient 0.1. The batch consists", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 212, + 734 + ], + "score": 1.0, + "content": "of 50,000 steps, of which", + "type": "text" + }, + { + "bbox": [ + 212, + 721, + 232, + 731 + ], + "score": 0.86, + "content": "2 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 232, + 720, + 452, + 734 + ], + "score": 1.0, + "content": "comes from target task episodes, while the remaining", + "type": "text" + }, + { + "bbox": [ + 452, + 721, + 472, + 731 + ], + "score": 0.86, + "content": "7 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 472, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "is from", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5 + } + ], + "page_idx": 12, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 301, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 298, + 750, + 312, + 763 + ], + "spans": [ + { + "bbox": [ + 298, + 750, + 312, + 763 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 13, + "width": 14 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [], + "index": 0.5, + "bbox_fs": [ + 105, + 81, + 505, + 105 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 110, + 505, + 177 + ], + "lines": [ + { + "bbox": [ + 106, + 110, + 505, + 123 + ], + "spans": [ + { + "bbox": [ + 106, + 110, + 318, + 123 + ], + "score": 1.0, + "content": "Fig. 6 (left) shows what happens when p(Light off)", + "type": "text" + }, + { + "bbox": [ + 318, + 111, + 338, + 121 + ], + "score": 0.46, + "content": "\\scriptstyle 1 = 0 . 3", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 110, + 505, + 123 + ], + "score": 1.0, + "content": ". Here reverse self-play works well, but", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 104, + 121, + 506, + 134 + ], + "spans": [ + { + "bbox": [ + 104, + 121, + 506, + 134 + ], + "score": 1.0, + "content": "repeat self-play does poorly. As discussed above, this flipping, relative to the previous experiment,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 131, + 505, + 146 + ], + "spans": [ + { + "bbox": [ + 105, + 131, + 505, + 146 + ], + "score": 1.0, + "content": "can be explained as follows: low p(Light off) means that Bob’s task in reverse self-play will typically", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 144, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 106, + 144, + 505, + 155 + ], + "score": 1.0, + "content": "involve returning the light to the on position (irrespective of how Alice left it), the same function", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "score": 1.0, + "content": "that must be performed in the target task. The opposite situation applies for repeat self-play, where", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 164, + 469, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 469, + 178 + ], + "score": 1.0, + "content": "Bob needs to encounter the light typically in the off position to help him with the test task.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 4.5, + "bbox_fs": [ + 104, + 110, + 506, + 178 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 182, + 505, + 226 + ], + "lines": [ + { + "bbox": [ + 105, + 182, + 505, + 195 + ], + "spans": [ + { + "bbox": [ + 105, + 182, + 505, + 195 + ], + "score": 1.0, + "content": "In Fig. 6 (right) we systematically vary p(Light off) between 0.1 and 0.9. The y-axis shows the", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 193, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 505, + 206 + ], + "score": 1.0, + "content": "speed-up (reduction in target task episodes) relative to training purely on the target-task for runs", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 204, + 505, + 217 + ], + "spans": [ + { + "bbox": [ + 105, + 204, + 505, + 217 + ], + "score": 1.0, + "content": "where the reward goes above -2. Unsuccessful runs are given a unity speed-up factor. The curves", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 216, + 480, + 227 + ], + "spans": [ + { + "bbox": [ + 106, + 216, + 480, + 227 + ], + "score": 1.0, + "content": "show that when the self-play task is not biased against the target task it can help significantly.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 182, + 505, + 227 + ] + }, + { + "type": "image", + "bbox": [ + 136, + 237, + 474, + 370 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 136, + 237, + 474, + 370 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 136, + 237, + 474, + 370 + ], + "spans": [ + { + "bbox": [ + 136, + 237, + 474, + 370 + ], + "score": 0.969, + "type": "image", + "image_path": "9dea24e2b8a3722d9cd26042796350f4c072933e9ae2a56930497eb412a13080.jpg" + } + ] + } + ], + "index": 13, + "virtual_lines": [ + { + "bbox": [ + 136, + 237, + 474, + 281.3333333333333 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 136, + 281.3333333333333, + 474, + 325.66666666666663 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 136, + 325.66666666666663, + 474, + 369.99999999999994 + ], + "spans": [], + "index": 14 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 379, + 505, + 478 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 378, + 506, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 506, + 392 + ], + "score": 1.0, + "content": "Figure 6: Left: The performance of self-play when p(Light off) set to 0.3. Here the reverse form", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 390, + 505, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 505, + 402 + ], + "score": 1.0, + "content": "of self-play works well (more details in the text). Right: Reduction in target task episodes relative", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 401, + 506, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 506, + 414 + ], + "score": 1.0, + "content": "to training purely on the target-task as the distance between self-play and the target task varies (for", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 411, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 505, + 425 + ], + "score": 1.0, + "content": "runs where the reward goes above -2 on the Mazebase task – unsuccessful runs are given a unity", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 423, + 506, + 435 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 198, + 435 + ], + "score": 1.0, + "content": "speed-up factor). The", + "type": "text" + }, + { + "bbox": [ + 199, + 425, + 206, + 435 + ], + "score": 0.79, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 206, + 423, + 307, + 435 + ], + "score": 1.0, + "content": "axis is the speedup, and", + "type": "text" + }, + { + "bbox": [ + 308, + 425, + 315, + 433 + ], + "score": 0.75, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 423, + 506, + 435 + ], + "score": 1.0, + "content": "axis is p(Light off). For reverse self-play, the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 434, + 505, + 446 + ], + "spans": [ + { + "bbox": [ + 106, + 434, + 505, + 446 + ], + "score": 1.0, + "content": "low p(Light off) corresponds to having self-play and target tasks be similar to one another, while", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 445, + 506, + 458 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 506, + 458 + ], + "score": 1.0, + "content": "the opposite applies to repeat self-play. For both forms, significant speedups are achieved when", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 456, + 505, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 505, + 469 + ], + "score": 1.0, + "content": "self-play is similar to the target tasks, but the effect diminishes when self-play is biased against the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 467, + 153, + 480 + ], + "spans": [ + { + "bbox": [ + 104, + 467, + 153, + 480 + ], + "score": 1.0, + "content": "target task.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 19 + } + ], + "index": 16.0 + }, + { + "type": "title", + "bbox": [ + 108, + 504, + 295, + 517 + ], + "lines": [ + { + "bbox": [ + 105, + 503, + 297, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 503, + 297, + 519 + ], + "score": 1.0, + "content": "D SWIMMERGATHER EXPERIMENT", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 529, + 505, + 573 + ], + "lines": [ + { + "bbox": [ + 104, + 528, + 506, + 542 + ], + "spans": [ + { + "bbox": [ + 104, + 528, + 506, + 542 + ], + "score": 1.0, + "content": "In Fig. 7 shows details of a single training run. The changes in Alice’s behavior, observed in Fig. 7(c)", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 540, + 506, + 553 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 553 + ], + "score": 1.0, + "content": "and (d), correlate with Alice and Bob’s reward (Fig. 7(b)) and, initially at least, to the reward on the", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 551, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 505, + 563 + ], + "score": 1.0, + "content": "test target (Fig. 7(a)). In Fig. 8 we visualize for a single training run the locations where Alice hands", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 563, + 423, + 574 + ], + "spans": [ + { + "bbox": [ + 106, + 563, + 423, + 574 + ], + "score": 1.0, + "content": "over to Bob at different stages of training, showing how the distribution varies.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5, + "bbox_fs": [ + 104, + 528, + 506, + 574 + ] + }, + { + "type": "image", + "bbox": [ + 107, + 583, + 503, + 661 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 583, + 503, + 661 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 107, + 583, + 503, + 661 + ], + "spans": [ + { + "bbox": [ + 107, + 583, + 503, + 661 + ], + "score": 0.962, + "type": "image", + "image_path": "b10cab091594486bf3cd8e30bf5f5e097c7495e15a6c3fc55af13e6bba396f50.jpg" + } + ] + } + ], + "index": 30, + "virtual_lines": [ + { + "bbox": [ + 107, + 583, + 503, + 609.0 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 107, + 609.0, + 503, + 635.0 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 107, + 635.0, + 503, + 661.0 + ], + "spans": [], + "index": 31 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 660, + 504, + 693 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 659, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 506, + 672 + ], + "score": 1.0, + "content": "Figure 7: A single SwimmerGather training run. (a): Rewards on target task. (b): Rewards from", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "score": 1.0, + "content": "reversible self-play. (c): The number of actions taken by Alice. (d): Distance that Alice travels", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 682, + 207, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 207, + 694 + ], + "score": 1.0, + "content": "before switching to Bob.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33 + } + ], + "index": 31.5 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "In the TRPO experiment, we used step size 0.01 and damping coefficient 0.1. The batch consists", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 212, + 734 + ], + "score": 1.0, + "content": "of 50,000 steps, of which", + "type": "text" + }, + { + "bbox": [ + 212, + 721, + 232, + 731 + ], + "score": 0.86, + "content": "2 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 232, + 720, + 452, + 734 + ], + "score": 1.0, + "content": "comes from target task episodes, while the remaining", + "type": "text" + }, + { + "bbox": [ + 452, + 721, + 472, + 731 + ], + "score": 0.86, + "content": "7 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 472, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "is from", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 225, + 505, + 237 + ], + "spans": [ + { + "bbox": [ + 106, + 225, + 258, + 236 + ], + "score": 1.0, + "content": "self-play. The self-play reward scale", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 258, + 227, + 266, + 237 + ], + "score": 0.81, + "content": "\\gamma", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 267, + 225, + 505, + 236 + ], + "score": 1.0, + "content": "set to 0.005. We used two separate network for actor and", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 236, + 446, + 249 + ], + "spans": [ + { + "bbox": [ + 106, + 236, + 414, + 249 + ], + "score": 1.0, + "content": "critic, and the critic network has L2 weight regularization with coefficient of", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 414, + 236, + 442, + 247 + ], + "score": 0.86, + "content": "1 e - 5", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 442, + 236, + 446, + 249 + ], + "score": 1.0, + "content": ".", + "type": "text", + "cross_page": true + } + ], + "index": 7 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 709, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 155, + 80, + 455, + 155 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 155, + 80, + 455, + 155 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 155, + 80, + 455, + 155 + ], + "spans": [ + { + "bbox": [ + 155, + 80, + 455, + 155 + ], + "score": 0.947, + "type": "image", + "image_path": "b209fac1472f9619db92043d1ca7cfb06e742f027316975d973929360291b5f7.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 155, + 80, + 455, + 105.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 155, + 105.0, + 455, + 130.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 155, + 130.0, + 455, + 155.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 162, + 505, + 195 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 161, + 505, + 175 + ], + "spans": [ + { + "bbox": [ + 105, + 161, + 505, + 175 + ], + "score": 1.0, + "content": "Figure 8: Plot of Alice’s location at time of STOP action for the SwimmerGather training run", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 173, + 505, + 186 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 505, + 186 + ], + "score": 1.0, + "content": "shown in Fig. 7, for different stages of training. Note how Alice’s distribution changes as Bob learns", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 183, + 180, + 196 + ], + "spans": [ + { + "bbox": [ + 105, + 183, + 180, + 196 + ], + "score": 1.0, + "content": "to solve her tasks.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 106, + 225, + 503, + 248 + ], + "lines": [ + { + "bbox": [ + 106, + 225, + 505, + 237 + ], + "spans": [ + { + "bbox": [ + 106, + 225, + 258, + 236 + ], + "score": 1.0, + "content": "self-play. The self-play reward scale", + "type": "text" + }, + { + "bbox": [ + 258, + 227, + 266, + 237 + ], + "score": 0.81, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 267, + 225, + 505, + 236 + ], + "score": 1.0, + "content": "set to 0.005. We used two separate network for actor and", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 236, + 446, + 249 + ], + "spans": [ + { + "bbox": [ + 106, + 236, + 414, + 249 + ], + "score": 1.0, + "content": "critic, and the critic network has L2 weight regularization with coefficient of", + "type": "text" + }, + { + "bbox": [ + 414, + 236, + 442, + 247 + ], + "score": 0.86, + "content": "1 e - 5", + "type": "inline_equation" + }, + { + "bbox": [ + 442, + 236, + 446, + 249 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5 + }, + { + "type": "title", + "bbox": [ + 108, + 267, + 261, + 280 + ], + "lines": [ + { + "bbox": [ + 105, + 266, + 263, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 266, + 263, + 281 + ], + "score": 1.0, + "content": "E STARCRAFT EXPERIMENT", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 293, + 505, + 327 + ], + "lines": [ + { + "bbox": [ + 106, + 294, + 505, + 305 + ], + "spans": [ + { + "bbox": [ + 106, + 294, + 505, + 305 + ], + "score": 1.0, + "content": "We call units that perform action as active unit. This includes worker units (SCVs), the command", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 304, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 106, + 304, + 505, + 316 + ], + "score": 1.0, + "content": "center, and barrack. The agent controls multiple active units in parallel. At each time step, an action", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 313, + 202, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 117, + 330 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 117, + 317, + 123, + 326 + ], + "score": 0.63, + "content": "\\because", + "type": "inline_equation" + }, + { + "bbox": [ + 123, + 313, + 202, + 330 + ], + "score": 1.0, + "content": "’th unit is output by", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + }, + { + "type": "interline_equation", + "bbox": [ + 275, + 329, + 335, + 344 + ], + "lines": [ + { + "bbox": [ + 275, + 329, + 335, + 344 + ], + "spans": [ + { + "bbox": [ + 275, + 329, + 335, + 344 + ], + "score": 0.92, + "content": "a _ { t } ^ { i } = \\pi ( s _ { t } ^ { i } , { \\hat { s } } _ { t } ) ,", + "type": "interline_equation", + "image_path": "156ee02f0e9d056f52f523961ab42ed450f94b80c470f6e89110890b2f7e5694.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 275, + 329, + 335, + 344 + ], + "spans": [], + "index": 12 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 350, + 505, + 384 + ], + "lines": [ + { + "bbox": [ + 105, + 349, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 133, + 364 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 349, + 143, + 362 + ], + "score": 0.88, + "content": "s _ { t } ^ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 143, + 349, + 301, + 364 + ], + "score": 1.0, + "content": "is a unit specific local observation, and", + "type": "text" + }, + { + "bbox": [ + 302, + 351, + 311, + 361 + ], + "score": 0.88, + "content": "\\hat { s } _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 349, + 435, + 364 + ], + "score": 1.0, + "content": "is an global observation. With", + "type": "text" + }, + { + "bbox": [ + 435, + 349, + 444, + 362 + ], + "score": 0.88, + "content": "s _ { t } ^ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 445, + 349, + 505, + 364 + ], + "score": 1.0, + "content": ", a unit can see", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 361, + 505, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 121, + 374 + ], + "score": 1.0, + "content": "the", + "type": "text" + }, + { + "bbox": [ + 121, + 362, + 148, + 372 + ], + "score": 0.3, + "content": "6 4 \\mathrm { x } 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 149, + 361, + 505, + 374 + ], + "score": 1.0, + "content": "area around it with a resolution of 4 (unit’s type is also visible). The global observation", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 371, + 378, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 378, + 385 + ], + "score": 1.0, + "content": "contains the number of units and accumulated minerals in the game", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14 + }, + { + "type": "interline_equation", + "bbox": [ + 193, + 391, + 417, + 406 + ], + "lines": [ + { + "bbox": [ + 193, + 391, + 417, + 406 + ], + "spans": [ + { + "bbox": [ + 193, + 391, + 417, + 406 + ], + "score": 0.88, + "content": "\\hat { s } _ { t } = \\{ \\lfloor N _ { \\mathrm { o r e } } / 2 5 \\rfloor , N _ { \\mathrm { S C V } } , N _ { \\mathrm { B a r r a c k } } , N _ { \\mathrm { S u p p l y D e p o t } } , N _ { \\mathrm { M a r i n e s } } \\} .", + "type": "interline_equation", + "image_path": "ff6abc688e06380951317d58f005e61f97237ee5436c2bd9634ef83d50dcc387.jpg" + } + ] + } + ], + "index": 16, + "virtual_lines": [ + { + "bbox": [ + 193, + 391, + 417, + 406 + ], + "spans": [], + "index": 16 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 419, + 396, + 432 + ], + "lines": [ + { + "bbox": [ + 106, + 419, + 397, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 419, + 397, + 433 + ], + "score": 1.0, + "content": "In self-play, Bob perceives only the global observation of his target state", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "interline_equation", + "bbox": [ + 275, + 438, + 334, + 453 + ], + "lines": [ + { + "bbox": [ + 275, + 438, + 334, + 453 + ], + "spans": [ + { + "bbox": [ + 275, + 438, + 334, + 453 + ], + "score": 0.91, + "content": "\\pi _ { B } \\big ( s _ { t } ^ { i } , \\hat { s } _ { t } , \\hat { s } ^ { * } \\big ) ,", + "type": "interline_equation", + "image_path": "427eaee0cb08feb51d5139d676fe9fc3a30b7814f19234f39e435dea75c4a225.jpg" + } + ] + } + ], + "index": 18, + "virtual_lines": [ + { + "bbox": [ + 275, + 438, + 334, + 453 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 461, + 403, + 473 + ], + "lines": [ + { + "bbox": [ + 106, + 459, + 404, + 474 + ], + "spans": [ + { + "bbox": [ + 106, + 459, + 133, + 474 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 462, + 144, + 471 + ], + "score": 0.87, + "content": "\\hat { s } ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 459, + 404, + 474 + ], + "score": 1.0, + "content": "is the final global observation of Alice. Bob will succeed only if", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "interline_equation", + "bbox": [ + 268, + 480, + 342, + 495 + ], + "lines": [ + { + "bbox": [ + 268, + 480, + 342, + 495 + ], + "spans": [ + { + "bbox": [ + 268, + 480, + 342, + 495 + ], + "score": 0.88, + "content": "\\begin{array} { r l } { \\forall i } & { { } \\hat { s } _ { t } [ i ] \\geq \\hat { s } ^ { * } [ i ] . } \\end{array}", + "type": "interline_equation", + "image_path": "b6e169b370ad675a3175726e8c60401730d9e9a20a4f681f10d0dd6b5b178f99.jpg" + } + ] + } + ], + "index": 20, + "virtual_lines": [ + { + "bbox": [ + 268, + 480, + 342, + 495 + ], + "spans": [], + "index": 20 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 508, + 505, + 554 + ], + "lines": [ + { + "bbox": [ + 105, + 508, + 506, + 521 + ], + "spans": [ + { + "bbox": [ + 105, + 508, + 506, + 521 + ], + "score": 1.0, + "content": "Table 2 shows the action space of different unit types controlled by the agent. The number of", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 520, + 506, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 520, + 506, + 532 + ], + "score": 1.0, + "content": "possible action is the same for all units since they controlled by a single model (unit type is encoded", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 531, + 505, + 544 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 505, + 544 + ], + "score": 1.0, + "content": "in the observation), but the meaning of actions differ according to unit type. An empty cell mean", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 541, + 454, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 454, + 555 + ], + "score": 1.0, + "content": "that the unit does nothing (nothing is sent to StarCraft, so the previous action persists).", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 107, + 558, + 505, + 592 + ], + "lines": [ + { + "bbox": [ + 105, + 558, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 505, + 572 + ], + "score": 1.0, + "content": "The more complexes actions “mine minerals”, “build a barracks”, “build a supply depot” have the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 570, + 506, + 582 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 506, + 582 + ], + "score": 1.0, + "content": "following semantics, respectively: mine the mineral closest to the current unit, build a barracks at", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 581, + 453, + 593 + ], + "spans": [ + { + "bbox": [ + 106, + 581, + 453, + 593 + ], + "score": 1.0, + "content": "the position of the current unit, build a supply depot on the position of the current unit.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 597, + 505, + 653 + ], + "lines": [ + { + "bbox": [ + 106, + 597, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 597, + 505, + 609 + ], + "score": 1.0, + "content": "Some actions are ignored under certain conditions: “mining” action is ignored if the distance to the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 607, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 505, + 622 + ], + "score": 1.0, + "content": "closest mineral is greater than 12; “switch to Bob” is ignored if Bob is already in control; “building”", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 619, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 106, + 619, + 505, + 632 + ], + "score": 1.0, + "content": "and “training” actions are ignored if there is not enough resources; the actions that create a new", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 630, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 505, + 642 + ], + "score": 1.0, + "content": "SCV or a barracks are ignored if the number of active units is reached the limit of 10. Also “build”", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 641, + 430, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 430, + 654 + ], + "score": 1.0, + "content": "actions will be ignored if there is not enough room to build at the unit’s location.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 108, + 658, + 502, + 682 + ], + "lines": [ + { + "bbox": [ + 106, + 658, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 106, + 659, + 351, + 673 + ], + "score": 1.0, + "content": "For the count-based exploration, we gave an extra reward of", + "type": "text" + }, + { + "bbox": [ + 352, + 658, + 399, + 672 + ], + "score": 0.92, + "content": "\\alpha / \\sqrt { N ( \\hat { s _ { t } } ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 659, + 484, + 673 + ], + "score": 1.0, + "content": "at every step, where", + "type": "text" + }, + { + "bbox": [ + 484, + 660, + 494, + 670 + ], + "score": 0.8, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 659, + 505, + 673 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 671, + 485, + 682 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 218, + 682 + ], + "score": 1.0, + "content": "the visit count function and", + "type": "text" + }, + { + "bbox": [ + 218, + 671, + 227, + 682 + ], + "score": 0.87, + "content": "\\hat { s _ { t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 671, + 365, + 682 + ], + "score": 1.0, + "content": "is a global observation. We found", + "type": "text" + }, + { + "bbox": [ + 365, + 672, + 399, + 681 + ], + "score": 0.86, + "content": "\\alpha = 0 . 1", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 671, + 485, + 682 + ], + "score": 1.0, + "content": "to be works the best.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33.5 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "score": 1.0, + "content": "In Fig. 9 we show the result of an additional experiment where we extended the length of the episode", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "from 200 to 300, giving more time to the agent for development. The self-play still outperforms", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "baselines methods. Note that to make more than 6 marines, an agent has to build a supply depot as", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 721, + 182, + 731 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 182, + 731 + ], + "score": 1.0, + "content": "well as a barracks.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5 + } + ], + "page_idx": 13, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 763 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 763 + ], + "score": 1.0, + "content": "14", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 155, + 80, + 455, + 155 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 155, + 80, + 455, + 155 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 155, + 80, + 455, + 155 + ], + "spans": [ + { + "bbox": [ + 155, + 80, + 455, + 155 + ], + "score": 0.947, + "type": "image", + "image_path": "b209fac1472f9619db92043d1ca7cfb06e742f027316975d973929360291b5f7.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 155, + 80, + 455, + 105.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 155, + 105.0, + 455, + 130.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 155, + 130.0, + 455, + 155.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 162, + 505, + 195 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 161, + 505, + 175 + ], + "spans": [ + { + "bbox": [ + 105, + 161, + 505, + 175 + ], + "score": 1.0, + "content": "Figure 8: Plot of Alice’s location at time of STOP action for the SwimmerGather training run", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 173, + 505, + 186 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 505, + 186 + ], + "score": 1.0, + "content": "shown in Fig. 7, for different stages of training. Note how Alice’s distribution changes as Bob learns", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 183, + 180, + 196 + ], + "spans": [ + { + "bbox": [ + 105, + 183, + 180, + 196 + ], + "score": 1.0, + "content": "to solve her tasks.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 106, + 225, + 503, + 248 + ], + "lines": [], + "index": 6.5, + "bbox_fs": [ + 106, + 225, + 505, + 249 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 108, + 267, + 261, + 280 + ], + "lines": [ + { + "bbox": [ + 105, + 266, + 263, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 266, + 263, + 281 + ], + "score": 1.0, + "content": "E STARCRAFT EXPERIMENT", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 293, + 505, + 327 + ], + "lines": [ + { + "bbox": [ + 106, + 294, + 505, + 305 + ], + "spans": [ + { + "bbox": [ + 106, + 294, + 505, + 305 + ], + "score": 1.0, + "content": "We call units that perform action as active unit. This includes worker units (SCVs), the command", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 304, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 106, + 304, + 505, + 316 + ], + "score": 1.0, + "content": "center, and barrack. The agent controls multiple active units in parallel. At each time step, an action", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 313, + 202, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 117, + 330 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 117, + 317, + 123, + 326 + ], + "score": 0.63, + "content": "\\because", + "type": "inline_equation" + }, + { + "bbox": [ + 123, + 313, + 202, + 330 + ], + "score": 1.0, + "content": "’th unit is output by", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10, + "bbox_fs": [ + 105, + 294, + 505, + 330 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 275, + 329, + 335, + 344 + ], + "lines": [ + { + "bbox": [ + 275, + 329, + 335, + 344 + ], + "spans": [ + { + "bbox": [ + 275, + 329, + 335, + 344 + ], + "score": 0.92, + "content": "a _ { t } ^ { i } = \\pi ( s _ { t } ^ { i } , { \\hat { s } } _ { t } ) ,", + "type": "interline_equation", + "image_path": "156ee02f0e9d056f52f523961ab42ed450f94b80c470f6e89110890b2f7e5694.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 275, + 329, + 335, + 344 + ], + "spans": [], + "index": 12 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 350, + 505, + 384 + ], + "lines": [ + { + "bbox": [ + 105, + 349, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 133, + 364 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 349, + 143, + 362 + ], + "score": 0.88, + "content": "s _ { t } ^ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 143, + 349, + 301, + 364 + ], + "score": 1.0, + "content": "is a unit specific local observation, and", + "type": "text" + }, + { + "bbox": [ + 302, + 351, + 311, + 361 + ], + "score": 0.88, + "content": "\\hat { s } _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 349, + 435, + 364 + ], + "score": 1.0, + "content": "is an global observation. With", + "type": "text" + }, + { + "bbox": [ + 435, + 349, + 444, + 362 + ], + "score": 0.88, + "content": "s _ { t } ^ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 445, + 349, + 505, + 364 + ], + "score": 1.0, + "content": ", a unit can see", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 361, + 505, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 121, + 374 + ], + "score": 1.0, + "content": "the", + "type": "text" + }, + { + "bbox": [ + 121, + 362, + 148, + 372 + ], + "score": 0.3, + "content": "6 4 \\mathrm { x } 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 149, + 361, + 505, + 374 + ], + "score": 1.0, + "content": "area around it with a resolution of 4 (unit’s type is also visible). The global observation", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 371, + 378, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 378, + 385 + ], + "score": 1.0, + "content": "contains the number of units and accumulated minerals in the game", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14, + "bbox_fs": [ + 105, + 349, + 505, + 385 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 193, + 391, + 417, + 406 + ], + "lines": [ + { + "bbox": [ + 193, + 391, + 417, + 406 + ], + "spans": [ + { + "bbox": [ + 193, + 391, + 417, + 406 + ], + "score": 0.88, + "content": "\\hat { s } _ { t } = \\{ \\lfloor N _ { \\mathrm { o r e } } / 2 5 \\rfloor , N _ { \\mathrm { S C V } } , N _ { \\mathrm { B a r r a c k } } , N _ { \\mathrm { S u p p l y D e p o t } } , N _ { \\mathrm { M a r i n e s } } \\} .", + "type": "interline_equation", + "image_path": "ff6abc688e06380951317d58f005e61f97237ee5436c2bd9634ef83d50dcc387.jpg" + } + ] + } + ], + "index": 16, + "virtual_lines": [ + { + "bbox": [ + 193, + 391, + 417, + 406 + ], + "spans": [], + "index": 16 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 419, + 396, + 432 + ], + "lines": [ + { + "bbox": [ + 106, + 419, + 397, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 419, + 397, + 433 + ], + "score": 1.0, + "content": "In self-play, Bob perceives only the global observation of his target state", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17, + "bbox_fs": [ + 106, + 419, + 397, + 433 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 275, + 438, + 334, + 453 + ], + "lines": [ + { + "bbox": [ + 275, + 438, + 334, + 453 + ], + "spans": [ + { + "bbox": [ + 275, + 438, + 334, + 453 + ], + "score": 0.91, + "content": "\\pi _ { B } \\big ( s _ { t } ^ { i } , \\hat { s } _ { t } , \\hat { s } ^ { * } \\big ) ,", + "type": "interline_equation", + "image_path": "427eaee0cb08feb51d5139d676fe9fc3a30b7814f19234f39e435dea75c4a225.jpg" + } + ] + } + ], + "index": 18, + "virtual_lines": [ + { + "bbox": [ + 275, + 438, + 334, + 453 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 461, + 403, + 473 + ], + "lines": [ + { + "bbox": [ + 106, + 459, + 404, + 474 + ], + "spans": [ + { + "bbox": [ + 106, + 459, + 133, + 474 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 462, + 144, + 471 + ], + "score": 0.87, + "content": "\\hat { s } ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 459, + 404, + 474 + ], + "score": 1.0, + "content": "is the final global observation of Alice. Bob will succeed only if", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19, + "bbox_fs": [ + 106, + 459, + 404, + 474 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 268, + 480, + 342, + 495 + ], + "lines": [ + { + "bbox": [ + 268, + 480, + 342, + 495 + ], + "spans": [ + { + "bbox": [ + 268, + 480, + 342, + 495 + ], + "score": 0.88, + "content": "\\begin{array} { r l } { \\forall i } & { { } \\hat { s } _ { t } [ i ] \\geq \\hat { s } ^ { * } [ i ] . } \\end{array}", + "type": "interline_equation", + "image_path": "b6e169b370ad675a3175726e8c60401730d9e9a20a4f681f10d0dd6b5b178f99.jpg" + } + ] + } + ], + "index": 20, + "virtual_lines": [ + { + "bbox": [ + 268, + 480, + 342, + 495 + ], + "spans": [], + "index": 20 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 508, + 505, + 554 + ], + "lines": [ + { + "bbox": [ + 105, + 508, + 506, + 521 + ], + "spans": [ + { + "bbox": [ + 105, + 508, + 506, + 521 + ], + "score": 1.0, + "content": "Table 2 shows the action space of different unit types controlled by the agent. The number of", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 520, + 506, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 520, + 506, + 532 + ], + "score": 1.0, + "content": "possible action is the same for all units since they controlled by a single model (unit type is encoded", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 531, + 505, + 544 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 505, + 544 + ], + "score": 1.0, + "content": "in the observation), but the meaning of actions differ according to unit type. An empty cell mean", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 541, + 454, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 454, + 555 + ], + "score": 1.0, + "content": "that the unit does nothing (nothing is sent to StarCraft, so the previous action persists).", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 508, + 506, + 555 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 558, + 505, + 592 + ], + "lines": [ + { + "bbox": [ + 105, + 558, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 505, + 572 + ], + "score": 1.0, + "content": "The more complexes actions “mine minerals”, “build a barracks”, “build a supply depot” have the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 570, + 506, + 582 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 506, + 582 + ], + "score": 1.0, + "content": "following semantics, respectively: mine the mineral closest to the current unit, build a barracks at", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 581, + 453, + 593 + ], + "spans": [ + { + "bbox": [ + 106, + 581, + 453, + 593 + ], + "score": 1.0, + "content": "the position of the current unit, build a supply depot on the position of the current unit.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26, + "bbox_fs": [ + 105, + 558, + 506, + 593 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 597, + 505, + 653 + ], + "lines": [ + { + "bbox": [ + 106, + 597, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 597, + 505, + 609 + ], + "score": 1.0, + "content": "Some actions are ignored under certain conditions: “mining” action is ignored if the distance to the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 607, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 505, + 622 + ], + "score": 1.0, + "content": "closest mineral is greater than 12; “switch to Bob” is ignored if Bob is already in control; “building”", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 619, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 106, + 619, + 505, + 632 + ], + "score": 1.0, + "content": "and “training” actions are ignored if there is not enough resources; the actions that create a new", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 630, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 505, + 642 + ], + "score": 1.0, + "content": "SCV or a barracks are ignored if the number of active units is reached the limit of 10. Also “build”", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 641, + 430, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 430, + 654 + ], + "score": 1.0, + "content": "actions will be ignored if there is not enough room to build at the unit’s location.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30, + "bbox_fs": [ + 105, + 597, + 505, + 654 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 658, + 502, + 682 + ], + "lines": [ + { + "bbox": [ + 106, + 658, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 106, + 659, + 351, + 673 + ], + "score": 1.0, + "content": "For the count-based exploration, we gave an extra reward of", + "type": "text" + }, + { + "bbox": [ + 352, + 658, + 399, + 672 + ], + "score": 0.92, + "content": "\\alpha / \\sqrt { N ( \\hat { s _ { t } } ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 659, + 484, + 673 + ], + "score": 1.0, + "content": "at every step, where", + "type": "text" + }, + { + "bbox": [ + 484, + 660, + 494, + 670 + ], + "score": 0.8, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 659, + 505, + 673 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 671, + 485, + 682 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 218, + 682 + ], + "score": 1.0, + "content": "the visit count function and", + "type": "text" + }, + { + "bbox": [ + 218, + 671, + 227, + 682 + ], + "score": 0.87, + "content": "\\hat { s _ { t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 671, + 365, + 682 + ], + "score": 1.0, + "content": "is a global observation. We found", + "type": "text" + }, + { + "bbox": [ + 365, + 672, + 399, + 681 + ], + "score": 0.86, + "content": "\\alpha = 0 . 1", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 671, + 485, + 682 + ], + "score": 1.0, + "content": "to be works the best.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33.5, + "bbox_fs": [ + 106, + 658, + 505, + 682 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "score": 1.0, + "content": "In Fig. 9 we show the result of an additional experiment where we extended the length of the episode", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "from 200 to 300, giving more time to the agent for development. The self-play still outperforms", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "baselines methods. Note that to make more than 6 marines, an agent has to build a supply depot as", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 721, + 182, + 731 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 182, + 731 + ], + "score": 1.0, + "content": "well as a barracks.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 687, + 505, + 731 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 157, + 80, + 453, + 175 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 157, + 80, + 453, + 175 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 157, + 80, + 453, + 175 + ], + "spans": [ + { + "bbox": [ + 157, + 80, + 453, + 175 + ], + "score": 0.979, + "html": "
Action IDSCVCommand centerBarraks
1move to righttrain SCVtrainamarine
2move to leftswitch to Bob
3move to top
4move to bottom
5mine minerals
6build a barracks
7build a supply depot
", + "type": "table", + "image_path": "eeb7bf8cf5b98404b925b939ab3deeb3fdfaa1950f2ad1c0354f300c0369bd95.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 157, + 80, + 453, + 111.66666666666667 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 157, + 111.66666666666667, + 453, + 143.33333333333334 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 157, + 143.33333333333334, + 453, + 175.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 190, + 183, + 420, + 195 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 190, + 183, + 420, + 196 + ], + "spans": [ + { + "bbox": [ + 190, + 183, + 420, + 196 + ], + "score": 1.0, + "content": "Table 2: Action space of different unit types in StarCraft.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "image", + "bbox": [ + 190, + 232, + 428, + 346 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 190, + 232, + 428, + 346 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 190, + 232, + 428, + 346 + ], + "spans": [ + { + "bbox": [ + 190, + 232, + 428, + 346 + ], + "score": 0.961, + "type": "image", + "image_path": "c530d592ad4225a204dc121b42651ffab7d714d60c8b59ff42a8c8e545970c76.jpg" + } + ] + } + ], + "index": 7.5, + "virtual_lines": [ + { + "bbox": [ + 190, + 232, + 428, + 246.25 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 190, + 246.25, + 428, + 260.5 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 190, + 260.5, + 428, + 274.75 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 190, + 274.75, + 428, + 289.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 190, + 289.0, + 428, + 303.25 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 190, + 303.25, + 428, + 317.5 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 190, + 317.5, + 428, + 331.75 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 190, + 331.75, + 428, + 346.0 + ], + "spans": [], + "index": 11 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 104, + 360, + 505, + 383 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 358, + 506, + 373 + ], + "spans": [ + { + "bbox": [ + 104, + 358, + 436, + 373 + ], + "score": 1.0, + "content": "Figure 9: Plot of reward on the StarCraft sub-task of training where episode length", + "type": "text" + }, + { + "bbox": [ + 437, + 362, + 455, + 371 + ], + "score": 0.9, + "content": "t _ { \\mathrm { M a x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 455, + 358, + 506, + 373 + ], + "score": 1.0, + "content": "is increased", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 370, + 137, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 137, + 383 + ], + "score": 1.0, + "content": "to 300.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5 + } + ], + "index": 10.0 + }, + { + "type": "title", + "bbox": [ + 108, + 411, + 243, + 424 + ], + "lines": [ + { + "bbox": [ + 105, + 410, + 244, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 244, + 427 + ], + "score": 1.0, + "content": "F FURTHER DISCUSSION", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "title", + "bbox": [ + 108, + 439, + 271, + 450 + ], + "lines": [ + { + "bbox": [ + 106, + 439, + 272, + 452 + ], + "spans": [ + { + "bbox": [ + 106, + 439, + 272, + 452 + ], + "score": 1.0, + "content": "F.1 META-EXPLORATION FOR ALICE", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 107, + 461, + 505, + 550 + ], + "lines": [ + { + "bbox": [ + 106, + 461, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 505, + 474 + ], + "score": 1.0, + "content": "We want Alice and Bob to explore the state (or state-action) space, and we would like Bob to", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 472, + 505, + 485 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 505, + 485 + ], + "score": 1.0, + "content": "be exposed to many different tasks. Because of the form of the standard reinforcement learning", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 484, + 505, + 496 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 505, + 496 + ], + "score": 1.0, + "content": "objective (expectation over rewards), Alice only wants to find the single hardest thing for Bob, and", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 495, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 505, + 507 + ], + "score": 1.0, + "content": "is not interested in the space of things that are hard for Bob. In the fully tabular setting, with fully", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 505, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 505, + 519 + ], + "score": 1.0, + "content": "reversible dynamics or with resetting, and without the constraints of realistic optimization strategies,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 517, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 505, + 529 + ], + "score": 1.0, + "content": "we saw in section 2.2 that this ends up forcing Bob and Alice to learn to make any state transition", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 528, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 505, + 540 + ], + "score": 1.0, + "content": "as efficiently as possible. However, with more realistic optimization methods or environments, and", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 539, + 435, + 551 + ], + "spans": [ + { + "bbox": [ + 106, + 539, + 435, + 551 + ], + "score": 1.0, + "content": "with function approximation, Bob and Alice can get stuck in sub-optimal minima.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 107, + 555, + 505, + 632 + ], + "lines": [ + { + "bbox": [ + 105, + 555, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 505, + 568 + ], + "score": 1.0, + "content": "For example, let us follow the argument in the third paragraph of Sec. 2.2, and assume that Bob and", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 565, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 505, + 579 + ], + "score": 1.0, + "content": "Alice are at an equilibrium (and that we are in the tabular, finite, Markovian setting), but now we", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 577, + 506, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 590 + ], + "score": 1.0, + "content": "can only update Bob’s and Alice’s policy locally. By this we mean that in our search for a better", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 588, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 505, + 601 + ], + "score": 1.0, + "content": "policy for Bob or Alice, we can only make small perturbations, as in policy gradient algorithms. In", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "this case, we can only guarantee that Bob runs a fast policy on challenges that Alice has non-zero", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 609, + 506, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 506, + 623 + ], + "score": 1.0, + "content": "probability of giving; but there is no guarantee that Alice will cover all possible challenges. With", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 621, + 464, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 464, + 634 + ], + "score": 1.0, + "content": "function approximation instead of tabular policies, we cannot make any guarantees at all.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 638, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 637, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 651 + ], + "score": 1.0, + "content": "Another example with a similar outcome but different mechanism can occur using the reverse game", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 649, + 505, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 505, + 660 + ], + "score": 1.0, + "content": "in an environment without fully reversible dynamics. In that case, it could be that the shortest", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 660, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 307, + 673 + ], + "score": 1.0, + "content": "expected number of steps to complete a challenge", + "type": "text" + }, + { + "bbox": [ + 307, + 660, + 340, + 672 + ], + "score": 0.92, + "content": "\\left( { { s } _ { 0 } } , { { s } _ { T } } \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 660, + 505, + 673 + ], + "score": 1.0, + "content": "is longer than the reverse, and indeed, so", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 670, + 504, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 504, + 683 + ], + "score": 1.0, + "content": "much longer that Alice should concentrate all her energy on this challenge to maximize her rewards.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "score": 1.0, + "content": "Thus there could be equilibria with Bob matching the fast policy only for a subset of challenges even", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 693, + 249, + 705 + ], + "spans": [ + { + "bbox": [ + 105, + 693, + 249, + 705 + ], + "score": 1.0, + "content": "if we allow non-local optimization.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 33.5 + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 503, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "The result is that Alice can end up in a policy that is not ideal for our purposes. In figure 8 we show", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 720, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 505, + 732 + ], + "score": 1.0, + "content": "the distributions of where Alice cedes control to Bob in the swimmer task. We can see that Alice has", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37.5 + } + ], + "page_idx": 14, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 301, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 157, + 80, + 453, + 175 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 157, + 80, + 453, + 175 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 157, + 80, + 453, + 175 + ], + "spans": [ + { + "bbox": [ + 157, + 80, + 453, + 175 + ], + "score": 0.979, + "html": "
Action IDSCVCommand centerBarraks
1move to righttrain SCVtrainamarine
2move to leftswitch to Bob
3move to top
4move to bottom
5mine minerals
6build a barracks
7build a supply depot
", + "type": "table", + "image_path": "eeb7bf8cf5b98404b925b939ab3deeb3fdfaa1950f2ad1c0354f300c0369bd95.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 157, + 80, + 453, + 111.66666666666667 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 157, + 111.66666666666667, + 453, + 143.33333333333334 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 157, + 143.33333333333334, + 453, + 175.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 190, + 183, + 420, + 195 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 190, + 183, + 420, + 196 + ], + "spans": [ + { + "bbox": [ + 190, + 183, + 420, + 196 + ], + "score": 1.0, + "content": "Table 2: Action space of different unit types in StarCraft.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "image", + "bbox": [ + 190, + 232, + 428, + 346 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 190, + 232, + 428, + 346 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 190, + 232, + 428, + 346 + ], + "spans": [ + { + "bbox": [ + 190, + 232, + 428, + 346 + ], + "score": 0.961, + "type": "image", + "image_path": "c530d592ad4225a204dc121b42651ffab7d714d60c8b59ff42a8c8e545970c76.jpg" + } + ] + } + ], + "index": 7.5, + "virtual_lines": [ + { + "bbox": [ + 190, + 232, + 428, + 246.25 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 190, + 246.25, + 428, + 260.5 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 190, + 260.5, + 428, + 274.75 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 190, + 274.75, + 428, + 289.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 190, + 289.0, + 428, + 303.25 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 190, + 303.25, + 428, + 317.5 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 190, + 317.5, + 428, + 331.75 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 190, + 331.75, + 428, + 346.0 + ], + "spans": [], + "index": 11 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 104, + 360, + 505, + 383 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 358, + 506, + 373 + ], + "spans": [ + { + "bbox": [ + 104, + 358, + 436, + 373 + ], + "score": 1.0, + "content": "Figure 9: Plot of reward on the StarCraft sub-task of training where episode length", + "type": "text" + }, + { + "bbox": [ + 437, + 362, + 455, + 371 + ], + "score": 0.9, + "content": "t _ { \\mathrm { M a x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 455, + 358, + 506, + 373 + ], + "score": 1.0, + "content": "is increased", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 370, + 137, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 137, + 383 + ], + "score": 1.0, + "content": "to 300.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5 + } + ], + "index": 10.0 + }, + { + "type": "title", + "bbox": [ + 108, + 411, + 243, + 424 + ], + "lines": [ + { + "bbox": [ + 105, + 410, + 244, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 244, + 427 + ], + "score": 1.0, + "content": "F FURTHER DISCUSSION", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "title", + "bbox": [ + 108, + 439, + 271, + 450 + ], + "lines": [ + { + "bbox": [ + 106, + 439, + 272, + 452 + ], + "spans": [ + { + "bbox": [ + 106, + 439, + 272, + 452 + ], + "score": 1.0, + "content": "F.1 META-EXPLORATION FOR ALICE", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 107, + 461, + 505, + 550 + ], + "lines": [ + { + "bbox": [ + 106, + 461, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 505, + 474 + ], + "score": 1.0, + "content": "We want Alice and Bob to explore the state (or state-action) space, and we would like Bob to", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 472, + 505, + 485 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 505, + 485 + ], + "score": 1.0, + "content": "be exposed to many different tasks. Because of the form of the standard reinforcement learning", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 484, + 505, + 496 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 505, + 496 + ], + "score": 1.0, + "content": "objective (expectation over rewards), Alice only wants to find the single hardest thing for Bob, and", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 495, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 505, + 507 + ], + "score": 1.0, + "content": "is not interested in the space of things that are hard for Bob. In the fully tabular setting, with fully", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 505, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 505, + 519 + ], + "score": 1.0, + "content": "reversible dynamics or with resetting, and without the constraints of realistic optimization strategies,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 517, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 505, + 529 + ], + "score": 1.0, + "content": "we saw in section 2.2 that this ends up forcing Bob and Alice to learn to make any state transition", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 528, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 505, + 540 + ], + "score": 1.0, + "content": "as efficiently as possible. However, with more realistic optimization methods or environments, and", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 539, + 435, + 551 + ], + "spans": [ + { + "bbox": [ + 106, + 539, + 435, + 551 + ], + "score": 1.0, + "content": "with function approximation, Bob and Alice can get stuck in sub-optimal minima.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 461, + 505, + 551 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 555, + 505, + 632 + ], + "lines": [ + { + "bbox": [ + 105, + 555, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 505, + 568 + ], + "score": 1.0, + "content": "For example, let us follow the argument in the third paragraph of Sec. 2.2, and assume that Bob and", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 565, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 505, + 579 + ], + "score": 1.0, + "content": "Alice are at an equilibrium (and that we are in the tabular, finite, Markovian setting), but now we", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 577, + 506, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 590 + ], + "score": 1.0, + "content": "can only update Bob’s and Alice’s policy locally. By this we mean that in our search for a better", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 588, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 505, + 601 + ], + "score": 1.0, + "content": "policy for Bob or Alice, we can only make small perturbations, as in policy gradient algorithms. In", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "this case, we can only guarantee that Bob runs a fast policy on challenges that Alice has non-zero", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 609, + 506, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 506, + 623 + ], + "score": 1.0, + "content": "probability of giving; but there is no guarantee that Alice will cover all possible challenges. With", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 621, + 464, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 464, + 634 + ], + "score": 1.0, + "content": "function approximation instead of tabular policies, we cannot make any guarantees at all.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 555, + 506, + 634 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 638, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 637, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 651 + ], + "score": 1.0, + "content": "Another example with a similar outcome but different mechanism can occur using the reverse game", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 649, + 505, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 505, + 660 + ], + "score": 1.0, + "content": "in an environment without fully reversible dynamics. In that case, it could be that the shortest", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 660, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 307, + 673 + ], + "score": 1.0, + "content": "expected number of steps to complete a challenge", + "type": "text" + }, + { + "bbox": [ + 307, + 660, + 340, + 672 + ], + "score": 0.92, + "content": "\\left( { { s } _ { 0 } } , { { s } _ { T } } \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 660, + 505, + 673 + ], + "score": 1.0, + "content": "is longer than the reverse, and indeed, so", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 670, + 504, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 504, + 683 + ], + "score": 1.0, + "content": "much longer that Alice should concentrate all her energy on this challenge to maximize her rewards.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "score": 1.0, + "content": "Thus there could be equilibria with Bob matching the fast policy only for a subset of challenges even", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 693, + 249, + 705 + ], + "spans": [ + { + "bbox": [ + 105, + 693, + 249, + 705 + ], + "score": 1.0, + "content": "if we allow non-local optimization.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 637, + 505, + 705 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 503, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "The result is that Alice can end up in a policy that is not ideal for our purposes. In figure 8 we show", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 720, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 505, + 732 + ], + "score": 1.0, + "content": "the distributions of where Alice cedes control to Bob in the swimmer task. We can see that Alice has", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "a preferred direction. Ideally, in this environment, Alice would be teaching Bob how to get from any", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 501, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 501, + 106 + ], + "score": 1.0, + "content": "state to any other efficiently; but instead, she is mostly teaching him how to move in one direction.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + } + ], + "index": 37.5, + "bbox_fs": [ + 106, + 709, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "a preferred direction. Ideally, in this environment, Alice would be teaching Bob how to get from any", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 501, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 501, + 106 + ], + "score": 1.0, + "content": "state to any other efficiently; but instead, she is mostly teaching him how to move in one direction.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 108, + 110, + 504, + 143 + ], + "lines": [ + { + "bbox": [ + 106, + 110, + 506, + 123 + ], + "spans": [ + { + "bbox": [ + 106, + 110, + 506, + 123 + ], + "score": 1.0, + "content": "One possible approach to correcting this is to have multiple Alices, regularized so that they do not", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 121, + 505, + 134 + ], + "spans": [ + { + "bbox": [ + 105, + 121, + 505, + 134 + ], + "score": 1.0, + "content": "implement the same policy. More generally, we can investigate objectives for Alice that encourage", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 132, + 291, + 144 + ], + "spans": [ + { + "bbox": [ + 106, + 132, + 291, + 144 + ], + "score": 1.0, + "content": "her to cover a wider distribution of behaviors.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3 + }, + { + "type": "title", + "bbox": [ + 108, + 157, + 266, + 168 + ], + "lines": [ + { + "bbox": [ + 105, + 156, + 267, + 170 + ], + "spans": [ + { + "bbox": [ + 105, + 156, + 267, + 170 + ], + "score": 1.0, + "content": "F.2 COMMUNICATING VIA ACTIONS", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 107, + 177, + 505, + 266 + ], + "lines": [ + { + "bbox": [ + 105, + 178, + 506, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 178, + 506, + 190 + ], + "score": 1.0, + "content": "In this work we have limited Alice to propose tasks for Bob by doing them. This limitation is", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 189, + 506, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 189, + 506, + 201 + ], + "score": 1.0, + "content": "practical and effective in restricted environments that allow resetting or are (nearly) reversible. It", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 199, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 505, + 213 + ], + "score": 1.0, + "content": "allows a solution to three of the key difficulties of implementing the basic idea of “Alice proposes", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 210, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 505, + 223 + ], + "score": 1.0, + "content": "tasks, Bob does them”: parameterizing the sampling of tasks, representing and communicating the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 222, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 222, + 505, + 234 + ], + "score": 1.0, + "content": "tasks, and ensuring the appropriate level of difficulty of the tasks. Each of these is interesting in more", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 232, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 505, + 246 + ], + "score": 1.0, + "content": "general contexts. In this work, the tasks have incentivized efficient transitions. One can imagine", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 244, + 505, + 256 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 505, + 256 + ], + "score": 1.0, + "content": "other reward functions and task representations that incentivize discovering statistics of the states", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 254, + 499, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 499, + 267 + ], + "score": 1.0, + "content": "and state-transitions, for example models of their causality or temporal ordering, cluster structure.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 9.5 + } + ], + "page_idx": 15, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 752, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 14 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [], + "index": 0.5, + "bbox_fs": [ + 105, + 82, + 505, + 106 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 108, + 110, + 504, + 143 + ], + "lines": [ + { + "bbox": [ + 106, + 110, + 506, + 123 + ], + "spans": [ + { + "bbox": [ + 106, + 110, + 506, + 123 + ], + "score": 1.0, + "content": "One possible approach to correcting this is to have multiple Alices, regularized so that they do not", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 121, + 505, + 134 + ], + "spans": [ + { + "bbox": [ + 105, + 121, + 505, + 134 + ], + "score": 1.0, + "content": "implement the same policy. More generally, we can investigate objectives for Alice that encourage", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 132, + 291, + 144 + ], + "spans": [ + { + "bbox": [ + 106, + 132, + 291, + 144 + ], + "score": 1.0, + "content": "her to cover a wider distribution of behaviors.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3, + "bbox_fs": [ + 105, + 110, + 506, + 144 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 157, + 266, + 168 + ], + "lines": [ + { + "bbox": [ + 105, + 156, + 267, + 170 + ], + "spans": [ + { + "bbox": [ + 105, + 156, + 267, + 170 + ], + "score": 1.0, + "content": "F.2 COMMUNICATING VIA ACTIONS", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 107, + 177, + 505, + 266 + ], + "lines": [ + { + "bbox": [ + 105, + 178, + 506, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 178, + 506, + 190 + ], + "score": 1.0, + "content": "In this work we have limited Alice to propose tasks for Bob by doing them. This limitation is", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 189, + 506, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 189, + 506, + 201 + ], + "score": 1.0, + "content": "practical and effective in restricted environments that allow resetting or are (nearly) reversible. It", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 199, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 505, + 213 + ], + "score": 1.0, + "content": "allows a solution to three of the key difficulties of implementing the basic idea of “Alice proposes", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 210, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 505, + 223 + ], + "score": 1.0, + "content": "tasks, Bob does them”: parameterizing the sampling of tasks, representing and communicating the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 222, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 222, + 505, + 234 + ], + "score": 1.0, + "content": "tasks, and ensuring the appropriate level of difficulty of the tasks. Each of these is interesting in more", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 232, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 505, + 246 + ], + "score": 1.0, + "content": "general contexts. In this work, the tasks have incentivized efficient transitions. One can imagine", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 244, + 505, + 256 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 505, + 256 + ], + "score": 1.0, + "content": "other reward functions and task representations that incentivize discovering statistics of the states", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 254, + 499, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 499, + 267 + ], + "score": 1.0, + "content": "and state-transitions, for example models of their causality or temporal ordering, cluster structure.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 178, + 506, + 267 + ] + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file