diff --git "a/parse/train/S1x2PCNKDB/S1x2PCNKDB_middle.json" "b/parse/train/S1x2PCNKDB/S1x2PCNKDB_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/S1x2PCNKDB/S1x2PCNKDB_middle.json" @@ -0,0 +1,39812 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 106, + 79, + 511, + 96 + ], + "lines": [ + { + "bbox": [ + 105, + 78, + 514, + 99 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 514, + 99 + ], + "score": 1.0, + "content": "TASK-RELEVANT ADVERSARIAL IMITATION LEARNING", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 112, + 115, + 245, + 137 + ], + "lines": [ + { + "bbox": [ + 113, + 116, + 201, + 127 + ], + "spans": [ + { + "bbox": [ + 113, + 116, + 201, + 127 + ], + "score": 1.0, + "content": "Anonymous authors", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 111, + 126, + 245, + 138 + ], + "spans": [ + { + "bbox": [ + 111, + 126, + 245, + 138 + ], + "score": 1.0, + "content": "Paper under double-blind review", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1.5 + }, + { + "type": "title", + "bbox": [ + 278, + 166, + 333, + 179 + ], + "lines": [ + { + "bbox": [ + 276, + 165, + 336, + 181 + ], + "spans": [ + { + "bbox": [ + 276, + 165, + 336, + 181 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 143, + 196, + 469, + 328 + ], + "lines": [ + { + "bbox": [ + 142, + 196, + 469, + 208 + ], + "spans": [ + { + "bbox": [ + 142, + 196, + 469, + 208 + ], + "score": 1.0, + "content": "We show that a critical problem in adversarial imitation from high-dimensional", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 141, + 207, + 469, + 220 + ], + "spans": [ + { + "bbox": [ + 141, + 207, + 469, + 220 + ], + "score": 1.0, + "content": "sensory data is the tendency of discriminator networks to distinguish agent and", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 218, + 469, + 231 + ], + "spans": [ + { + "bbox": [ + 141, + 218, + 469, + 231 + ], + "score": 1.0, + "content": "expert behaviour using task-irrelevant features beyond the control of the agent. We", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 142, + 229, + 469, + 241 + ], + "spans": [ + { + "bbox": [ + 142, + 229, + 469, + 241 + ], + "score": 1.0, + "content": "analyze this problem in detail and propose a solution as well as several baselines", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 240, + 470, + 253 + ], + "spans": [ + { + "bbox": [ + 141, + 240, + 470, + 253 + ], + "score": 1.0, + "content": "that outperform standard Generative Adversarial Imitation Learning (GAIL). Our", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 251, + 470, + 264 + ], + "spans": [ + { + "bbox": [ + 141, + 251, + 470, + 264 + ], + "score": 1.0, + "content": "proposed solution, Task-Relevant Adversarial Imitation Learning (TRAIL), uses a", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 142, + 263, + 470, + 274 + ], + "spans": [ + { + "bbox": [ + 142, + 263, + 470, + 274 + ], + "score": 1.0, + "content": "constrained optimization objective to overcome task-irrelevant features. Compre-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 273, + 470, + 286 + ], + "spans": [ + { + "bbox": [ + 141, + 273, + 470, + 286 + ], + "score": 1.0, + "content": "hensive experiments show that TRAIL can solve challenging manipulation tasks", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 284, + 470, + 297 + ], + "spans": [ + { + "bbox": [ + 141, + 284, + 470, + 297 + ], + "score": 1.0, + "content": "from pixels by imitating human operators, where other agents such as behaviour", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 294, + 470, + 308 + ], + "spans": [ + { + "bbox": [ + 141, + 294, + 470, + 308 + ], + "score": 1.0, + "content": "cloning (BC), standard GAIL, improved GAIL variants including our newly pro-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 306, + 470, + 318 + ], + "spans": [ + { + "bbox": [ + 141, + 306, + 470, + 318 + ], + "score": 1.0, + "content": "posed baselines, and Deterministic Policy Gradients from Demonstrations (DPGfD)", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 317, + 447, + 329 + ], + "spans": [ + { + "bbox": [ + 141, + 317, + 447, + 329 + ], + "score": 1.0, + "content": "fail to find solutions, even when the other agents have access to task reward.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 9.5 + }, + { + "type": "title", + "bbox": [ + 108, + 361, + 205, + 374 + ], + "lines": [ + { + "bbox": [ + 105, + 360, + 208, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 208, + 377 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 390, + 505, + 468 + ], + "lines": [ + { + "bbox": [ + 106, + 390, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 505, + 403 + ], + "score": 1.0, + "content": "Generative Adversarial Networks (GANs) have produced breath-taking conditional image synthesis", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 401, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 505, + 414 + ], + "score": 1.0, + "content": "results (Goodfellow et al., 2014; Brock et al., 2019), and have inspired adversarial learning approaches", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 412, + 506, + 425 + ], + "spans": [ + { + "bbox": [ + 106, + 412, + 506, + 425 + ], + "score": 1.0, + "content": "to imitating behavior. In Generative Adversarial Imitation Learning (GAIL) (Ho & Ermon, 2016), a", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 421, + 507, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 507, + 437 + ], + "score": 1.0, + "content": "discriminator network is trained to distinguish agent and expert behaviour through its observations,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 433, + 506, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 506, + 448 + ], + "score": 1.0, + "content": "and is then used as a reward function. GAIL agents can overcome the exploration challenge by taking", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 444, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 505, + 459 + ], + "score": 1.0, + "content": "advantage of expert demonstrations, while also achieving high asymptotic performance by learning", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 456, + 201, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 201, + 470 + ], + "score": 1.0, + "content": "from agent experience.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 106, + 473, + 506, + 539 + ], + "lines": [ + { + "bbox": [ + 106, + 473, + 505, + 485 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 505, + 485 + ], + "score": 1.0, + "content": "Despite the huge promise of GAIL, it has not yet had the same impact as GANs; in particular, robust", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 483, + 506, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 497 + ], + "score": 1.0, + "content": "GAIL from pixels for control applications remains a challenge. Here, we study a key shortcoming", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 494, + 506, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 506, + 508 + ], + "score": 1.0, + "content": "of GAIL: the tendency of the discriminator to mainly exploit task-irrelevant features. For example,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 506, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 506, + 519 + ], + "score": 1.0, + "content": "by focusing on slight background differences, a discriminator can achieve perfect generalization,", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 517, + 506, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 506, + 529 + ], + "score": 1.0, + "content": "assigning zero reward to all held-out agent observations. However, this discriminator does not yield", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 528, + 345, + 540 + ], + "spans": [ + { + "bbox": [ + 106, + 528, + 345, + 540 + ], + "score": 1.0, + "content": "an informative reward function because it ignores behavior.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 26.5 + }, + { + "type": "image", + "bbox": [ + 110, + 559, + 499, + 679 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 110, + 559, + 499, + 679 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 559, + 499, + 679 + ], + "spans": [ + { + "bbox": [ + 110, + 559, + 499, + 679 + ], + "score": 0.972, + "type": "image", + "image_path": "21a1b85e2a28f46c1e51c7d95c791c9593dbf312cc715586c7be17a650a74728.jpg" + } + ] + } + ], + "index": 31, + "virtual_lines": [ + { + "bbox": [ + 110, + 559, + 499, + 599.0 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 110, + 599.0, + 499, + 639.0 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 110, + 639.0, + 499, + 679.0 + ], + "spans": [], + "index": 32 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 685, + 505, + 730 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 685, + 505, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 685, + 505, + 698 + ], + "score": 1.0, + "content": "Figure 1: GAIL and TRAIL succeed at lifting (a), but when distractor objects are added, GAIL fails", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 697, + 505, + 708 + ], + "spans": [ + { + "bbox": [ + 106, + 697, + 505, + 708 + ], + "score": 1.0, + "content": "while TRAIL succeeds (b). Due to robustness to initial conditions, TRAIL can stack from pixels while", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 708, + 505, + 720 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 720 + ], + "score": 1.0, + "content": "standard GAIL fails (c). We witness this difference again in insertion with distractors (d). A video", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 718, + 497, + 731 + ], + "spans": [ + { + "bbox": [ + 105, + 718, + 497, + 731 + ], + "score": 1.0, + "content": "showing agents performing these tasks can be seen at https://youtu.be/Rz5G15rDKcg .", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34.5 + } + ], + "index": 32.75 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 308, + 761 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 308, + 761 + ], + "score": 1.0, + "content": "1", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 106, + 79, + 511, + 96 + ], + "lines": [ + { + "bbox": [ + 105, + 78, + 514, + 99 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 514, + 99 + ], + "score": 1.0, + "content": "TASK-RELEVANT ADVERSARIAL IMITATION LEARNING", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 112, + 115, + 245, + 137 + ], + "lines": [ + { + "bbox": [ + 113, + 116, + 201, + 127 + ], + "spans": [ + { + "bbox": [ + 113, + 116, + 201, + 127 + ], + "score": 1.0, + "content": "Anonymous authors", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 111, + 126, + 245, + 138 + ], + "spans": [ + { + "bbox": [ + 111, + 126, + 245, + 138 + ], + "score": 1.0, + "content": "Paper under double-blind review", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1.5, + "bbox_fs": [ + 111, + 116, + 245, + 138 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 166, + 333, + 179 + ], + "lines": [ + { + "bbox": [ + 276, + 165, + 336, + 181 + ], + "spans": [ + { + "bbox": [ + 276, + 165, + 336, + 181 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 143, + 196, + 469, + 328 + ], + "lines": [ + { + "bbox": [ + 142, + 196, + 469, + 208 + ], + "spans": [ + { + "bbox": [ + 142, + 196, + 469, + 208 + ], + "score": 1.0, + "content": "We show that a critical problem in adversarial imitation from high-dimensional", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 141, + 207, + 469, + 220 + ], + "spans": [ + { + "bbox": [ + 141, + 207, + 469, + 220 + ], + "score": 1.0, + "content": "sensory data is the tendency of discriminator networks to distinguish agent and", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 218, + 469, + 231 + ], + "spans": [ + { + "bbox": [ + 141, + 218, + 469, + 231 + ], + "score": 1.0, + "content": "expert behaviour using task-irrelevant features beyond the control of the agent. We", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 142, + 229, + 469, + 241 + ], + "spans": [ + { + "bbox": [ + 142, + 229, + 469, + 241 + ], + "score": 1.0, + "content": "analyze this problem in detail and propose a solution as well as several baselines", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 240, + 470, + 253 + ], + "spans": [ + { + "bbox": [ + 141, + 240, + 470, + 253 + ], + "score": 1.0, + "content": "that outperform standard Generative Adversarial Imitation Learning (GAIL). Our", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 251, + 470, + 264 + ], + "spans": [ + { + "bbox": [ + 141, + 251, + 470, + 264 + ], + "score": 1.0, + "content": "proposed solution, Task-Relevant Adversarial Imitation Learning (TRAIL), uses a", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 142, + 263, + 470, + 274 + ], + "spans": [ + { + "bbox": [ + 142, + 263, + 470, + 274 + ], + "score": 1.0, + "content": "constrained optimization objective to overcome task-irrelevant features. Compre-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 273, + 470, + 286 + ], + "spans": [ + { + "bbox": [ + 141, + 273, + 470, + 286 + ], + "score": 1.0, + "content": "hensive experiments show that TRAIL can solve challenging manipulation tasks", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 284, + 470, + 297 + ], + "spans": [ + { + "bbox": [ + 141, + 284, + 470, + 297 + ], + "score": 1.0, + "content": "from pixels by imitating human operators, where other agents such as behaviour", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 294, + 470, + 308 + ], + "spans": [ + { + "bbox": [ + 141, + 294, + 470, + 308 + ], + "score": 1.0, + "content": "cloning (BC), standard GAIL, improved GAIL variants including our newly pro-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 306, + 470, + 318 + ], + "spans": [ + { + "bbox": [ + 141, + 306, + 470, + 318 + ], + "score": 1.0, + "content": "posed baselines, and Deterministic Policy Gradients from Demonstrations (DPGfD)", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 317, + 447, + 329 + ], + "spans": [ + { + "bbox": [ + 141, + 317, + 447, + 329 + ], + "score": 1.0, + "content": "fail to find solutions, even when the other agents have access to task reward.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 9.5, + "bbox_fs": [ + 141, + 196, + 470, + 329 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 361, + 205, + 374 + ], + "lines": [ + { + "bbox": [ + 105, + 360, + 208, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 208, + 377 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 390, + 505, + 468 + ], + "lines": [ + { + "bbox": [ + 106, + 390, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 505, + 403 + ], + "score": 1.0, + "content": "Generative Adversarial Networks (GANs) have produced breath-taking conditional image synthesis", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 401, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 505, + 414 + ], + "score": 1.0, + "content": "results (Goodfellow et al., 2014; Brock et al., 2019), and have inspired adversarial learning approaches", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 412, + 506, + 425 + ], + "spans": [ + { + "bbox": [ + 106, + 412, + 506, + 425 + ], + "score": 1.0, + "content": "to imitating behavior. In Generative Adversarial Imitation Learning (GAIL) (Ho & Ermon, 2016), a", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 421, + 507, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 507, + 437 + ], + "score": 1.0, + "content": "discriminator network is trained to distinguish agent and expert behaviour through its observations,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 433, + 506, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 506, + 448 + ], + "score": 1.0, + "content": "and is then used as a reward function. GAIL agents can overcome the exploration challenge by taking", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 444, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 505, + 459 + ], + "score": 1.0, + "content": "advantage of expert demonstrations, while also achieving high asymptotic performance by learning", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 456, + 201, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 201, + 470 + ], + "score": 1.0, + "content": "from agent experience.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20, + "bbox_fs": [ + 105, + 390, + 507, + 470 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 473, + 506, + 539 + ], + "lines": [ + { + "bbox": [ + 106, + 473, + 505, + 485 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 505, + 485 + ], + "score": 1.0, + "content": "Despite the huge promise of GAIL, it has not yet had the same impact as GANs; in particular, robust", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 483, + 506, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 497 + ], + "score": 1.0, + "content": "GAIL from pixels for control applications remains a challenge. Here, we study a key shortcoming", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 494, + 506, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 506, + 508 + ], + "score": 1.0, + "content": "of GAIL: the tendency of the discriminator to mainly exploit task-irrelevant features. For example,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 506, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 506, + 519 + ], + "score": 1.0, + "content": "by focusing on slight background differences, a discriminator can achieve perfect generalization,", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 517, + 506, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 506, + 529 + ], + "score": 1.0, + "content": "assigning zero reward to all held-out agent observations. However, this discriminator does not yield", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 528, + 345, + 540 + ], + "spans": [ + { + "bbox": [ + 106, + 528, + 345, + 540 + ], + "score": 1.0, + "content": "an informative reward function because it ignores behavior.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 473, + 506, + 540 + ] + }, + { + "type": "image", + "bbox": [ + 110, + 559, + 499, + 679 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 110, + 559, + 499, + 679 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 559, + 499, + 679 + ], + "spans": [ + { + "bbox": [ + 110, + 559, + 499, + 679 + ], + "score": 0.972, + "type": "image", + "image_path": "21a1b85e2a28f46c1e51c7d95c791c9593dbf312cc715586c7be17a650a74728.jpg" + } + ] + } + ], + "index": 31, + "virtual_lines": [ + { + "bbox": [ + 110, + 559, + 499, + 599.0 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 110, + 599.0, + 499, + 639.0 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 110, + 639.0, + 499, + 679.0 + ], + "spans": [], + "index": 32 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 685, + 505, + 730 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 685, + 505, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 685, + 505, + 698 + ], + "score": 1.0, + "content": "Figure 1: GAIL and TRAIL succeed at lifting (a), but when distractor objects are added, GAIL fails", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 697, + 505, + 708 + ], + "spans": [ + { + "bbox": [ + 106, + 697, + 505, + 708 + ], + "score": 1.0, + "content": "while TRAIL succeeds (b). Due to robustness to initial conditions, TRAIL can stack from pixels while", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 708, + 505, + 720 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 720 + ], + "score": 1.0, + "content": "standard GAIL fails (c). We witness this difference again in insertion with distractors (d). A video", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 718, + 497, + 731 + ], + "spans": [ + { + "bbox": [ + 105, + 718, + 497, + 731 + ], + "score": 1.0, + "content": "showing agents performing these tasks can be seen at https://youtu.be/Rz5G15rDKcg .", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34.5 + } + ], + "index": 32.75 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 127, + 65, + 483, + 169 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 127, + 65, + 483, + 169 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 127, + 65, + 483, + 169 + ], + "spans": [ + { + "bbox": [ + 127, + 65, + 483, + 169 + ], + "score": 0.963, + "type": "image", + "image_path": "862945eb66675f4de9e3964473bbe1038dacc00ee10aed40f2139ea575ebaafb.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 127, + 65, + 483, + 99.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 127, + 99.66666666666666, + 483, + 134.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 127, + 134.33333333333331, + 483, + 168.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 177, + 506, + 210 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 177, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 505, + 189 + ], + "score": 1.0, + "content": "Figure 2: Illustration of several task-irrelevant changes between the expert demonstrations and the", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 188, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 106, + 188, + 505, + 200 + ], + "score": 1.0, + "content": "distribution of agent observations, for the lift (red cube) task. The naively-trained discriminator", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 199, + 488, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 488, + 212 + ], + "score": 1.0, + "content": "network will use these differences rather than task performance to distinguish agent and expert.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 108, + 225, + 505, + 258 + ], + "lines": [ + { + "bbox": [ + 106, + 225, + 506, + 237 + ], + "spans": [ + { + "bbox": [ + 106, + 225, + 245, + 237 + ], + "score": 1.0, + "content": "Assuming there is an expert policy", + "type": "text" + }, + { + "bbox": [ + 245, + 227, + 259, + 236 + ], + "score": 0.86, + "content": "\\pi _ { E }", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 225, + 506, + 237 + ], + "score": 1.0, + "content": "that is optimal for an unknown reward function, here we refer", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 237, + 505, + 248 + ], + "spans": [ + { + "bbox": [ + 106, + 237, + 505, + 248 + ], + "score": 1.0, + "content": "to a feature as task-irrelevant if it does not affect that reward. For example, if the task is to lift a red", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 247, + 432, + 259 + ], + "spans": [ + { + "bbox": [ + 106, + 247, + 432, + 259 + ], + "score": 1.0, + "content": "block, the positions of other blocks would be task-irrelevant; see Figures 1 and 2.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 264, + 290, + 275 + ], + "lines": [ + { + "bbox": [ + 105, + 263, + 293, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 293, + 277 + ], + "score": 1.0, + "content": "This paper makes the following contributions:", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 129, + 284, + 505, + 405 + ], + "lines": [ + { + "bbox": [ + 130, + 284, + 505, + 297 + ], + "spans": [ + { + "bbox": [ + 130, + 284, + 505, + 297 + ], + "score": 1.0, + "content": "1. It reveals a fundamental limitation of GAIL by showing that discriminators do in practice", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 295, + 458, + 308 + ], + "spans": [ + { + "bbox": [ + 141, + 295, + 458, + 308 + ], + "score": 1.0, + "content": "exploit task-irrelevant information, thereby resulting in poor task performance.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 129, + 308, + 505, + 322 + ], + "spans": [ + { + "bbox": [ + 129, + 308, + 505, + 322 + ], + "score": 1.0, + "content": "2. It introduces powerful GAIL baselines. In particular, it shows that standard regularization", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 142, + 321, + 455, + 333 + ], + "spans": [ + { + "bbox": [ + 142, + 321, + 455, + 333 + ], + "score": 1.0, + "content": "and data augmentation are generally useful and improve upon standard GAIL.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 128, + 334, + 505, + 348 + ], + "spans": [ + { + "bbox": [ + 128, + 334, + 505, + 348 + ], + "score": 1.0, + "content": "3. It shows that these improvements to GAIL, as well as other improvements proposed by", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 345, + 505, + 360 + ], + "spans": [ + { + "bbox": [ + 141, + 345, + 505, + 360 + ], + "score": 1.0, + "content": "Reed et al. (2018), do not completely solve the problem, allowing GAIL agents to fail", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 357, + 395, + 369 + ], + "spans": [ + { + "bbox": [ + 141, + 357, + 395, + 369 + ], + "score": 1.0, + "content": "catastrophically with the addition of task-irrelevant distractors.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 129, + 371, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 129, + 371, + 505, + 384 + ], + "score": 1.0, + "content": "4. It introduces Task Relevant Adversarial Imitation Learning (TRAIL), using constrained", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 142, + 382, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 142, + 382, + 505, + 394 + ], + "score": 1.0, + "content": "optimization to force the discriminator to focus on the relevant aspects of the task, which", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 393, + 485, + 407 + ], + "spans": [ + { + "bbox": [ + 141, + 393, + 485, + 407 + ], + "score": 1.0, + "content": "improves performance dramatically on manipulation tasks from pixels (see Figure 1).", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 14.5 + }, + { + "type": "title", + "bbox": [ + 107, + 420, + 209, + 432 + ], + "lines": [ + { + "bbox": [ + 105, + 419, + 211, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 211, + 434 + ], + "score": 1.0, + "content": "2 RELATED WORK", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 444, + 505, + 478 + ], + "lines": [ + { + "bbox": [ + 105, + 444, + 506, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 506, + 457 + ], + "score": 1.0, + "content": "The use of demonstrations to help agent training has been studied extensively in robotics (Bakker", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 455, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 505, + 468 + ], + "score": 1.0, + "content": "& Kuniyoshi, 1996; Kawato et al., 1994; Miyamoto et al., 1996) with approaches ranging from", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 466, + 401, + 479 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 401, + 479 + ], + "score": 1.0, + "content": "Q-learning (Schaal, 1997) to behavioral cloning (BC) (Pomerleau, 1989).", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 106, + 483, + 505, + 549 + ], + "lines": [ + { + "bbox": [ + 105, + 483, + 505, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 505, + 496 + ], + "score": 1.0, + "content": "BC: BC is effective in solving many control problems (Pomerleau, 1989; Finn et al., 2017; Duan", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 493, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 505, + 507 + ], + "score": 1.0, + "content": "et al., 2017; Rahmatizadeh et al., 2018). It has also been successfully applied to initialize RL training", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 505, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 505, + 518 + ], + "score": 1.0, + "content": "(Rajeswaran et al., 2017). It, however, suffers from compounding errors as initial small deviations", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 516, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 505, + 529 + ], + "score": 1.0, + "content": "from the expert behaviors tend to cause bigger differences (Ross et al., 2011). This often necessitates", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 528, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 106, + 528, + 505, + 540 + ], + "score": 1.0, + "content": "a large number of demonstrations for satisfactory performance. Furthermore, BC typically does not", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 538, + 323, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 323, + 550 + ], + "score": 1.0, + "content": "lead to agents that are superior to their demonstrators.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 107, + 555, + 505, + 610 + ], + "lines": [ + { + "bbox": [ + 105, + 554, + 506, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 238, + 568 + ], + "score": 1.0, + "content": "Inverse RL: Ziebart et al. (2008);", + "type": "text" + }, + { + "bbox": [ + 239, + 555, + 253, + 567 + ], + "score": 0.43, + "content": "\\mathrm { N g }", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 554, + 343, + 568 + ], + "score": 1.0, + "content": "et al. (2000); Abbeel &", + "type": "text" + }, + { + "bbox": [ + 343, + 555, + 385, + 567 + ], + "score": 0.33, + "content": "\\mathrm { N g } \\left( 2 0 0 4 \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 554, + 506, + 568 + ], + "score": 1.0, + "content": "propose inverse reinforcement", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 564, + 505, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 505, + 580 + ], + "score": 1.0, + "content": "learning (IRL) as a way of learning reward functions from demonstrations. Reinforcement learning", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 578, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 106, + 578, + 505, + 590 + ], + "score": 1.0, + "content": "can then be used to optimize that learned reward. Recently, Finn et al. (2016b) approached continuous", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 586, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 505, + 603 + ], + "score": 1.0, + "content": "robotic control problems with success by applying Maximum Entropy IRL algorithms which are very", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 599, + 397, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 397, + 612 + ], + "score": 1.0, + "content": "closely related to GAIL (Finn et al., 2016a) and have similar drawbacks.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 615, + 505, + 671 + ], + "lines": [ + { + "bbox": [ + 105, + 615, + 507, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 507, + 629 + ], + "score": 1.0, + "content": "Learning from Demonstrations: Hester et al. (2018) developed deep Q-Learning from demonstra-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "score": 1.0, + "content": "tion (DQfD), in which expert trajectories are added to experience replay and jointly used to train", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 638, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 506, + 651 + ], + "score": 1.0, + "content": "agents along with their own experiences. This was later extended by Vecerik et al. (2017) and Pohlen", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "et al. (2018) to better handle sparse-reward problems in control and Atari games respectively. Despite", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 660, + 449, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 449, + 673 + ], + "score": 1.0, + "content": "their efficiency, this class of methods still requires access to rewards in order to learn.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "score": 1.0, + "content": "GAIL: Following the success of Generative Adversarial Networks (Goodfellow et al., 2014) in image", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 687, + 507, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 507, + 701 + ], + "score": 1.0, + "content": "generation, GAIL (Ho & Ermon, 2016) applies adversarial learning to the problem of imitation.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "Although many variants are introduced in the literature (Li et al., 2017; Fu et al., 2018; Merel et al.,", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 708, + 507, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 507, + 723 + ], + "score": 1.0, + "content": "2017; Zhu et al., 2018; Baram et al., 2017), making GAIL work for high-dimensional input spaces,", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 720, + 284, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 284, + 734 + ], + "score": 1.0, + "content": "particularly raw pixels, remains a challenge.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 42 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "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": [ + 127, + 65, + 483, + 169 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 127, + 65, + 483, + 169 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 127, + 65, + 483, + 169 + ], + "spans": [ + { + "bbox": [ + 127, + 65, + 483, + 169 + ], + "score": 0.963, + "type": "image", + "image_path": "862945eb66675f4de9e3964473bbe1038dacc00ee10aed40f2139ea575ebaafb.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 127, + 65, + 483, + 99.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 127, + 99.66666666666666, + 483, + 134.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 127, + 134.33333333333331, + 483, + 168.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 177, + 506, + 210 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 177, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 505, + 189 + ], + "score": 1.0, + "content": "Figure 2: Illustration of several task-irrelevant changes between the expert demonstrations and the", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 188, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 106, + 188, + 505, + 200 + ], + "score": 1.0, + "content": "distribution of agent observations, for the lift (red cube) task. The naively-trained discriminator", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 199, + 488, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 488, + 212 + ], + "score": 1.0, + "content": "network will use these differences rather than task performance to distinguish agent and expert.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 108, + 225, + 505, + 258 + ], + "lines": [ + { + "bbox": [ + 106, + 225, + 506, + 237 + ], + "spans": [ + { + "bbox": [ + 106, + 225, + 245, + 237 + ], + "score": 1.0, + "content": "Assuming there is an expert policy", + "type": "text" + }, + { + "bbox": [ + 245, + 227, + 259, + 236 + ], + "score": 0.86, + "content": "\\pi _ { E }", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 225, + 506, + 237 + ], + "score": 1.0, + "content": "that is optimal for an unknown reward function, here we refer", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 237, + 505, + 248 + ], + "spans": [ + { + "bbox": [ + 106, + 237, + 505, + 248 + ], + "score": 1.0, + "content": "to a feature as task-irrelevant if it does not affect that reward. For example, if the task is to lift a red", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 247, + 432, + 259 + ], + "spans": [ + { + "bbox": [ + 106, + 247, + 432, + 259 + ], + "score": 1.0, + "content": "block, the positions of other blocks would be task-irrelevant; see Figures 1 and 2.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7, + "bbox_fs": [ + 106, + 225, + 506, + 259 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 264, + 290, + 275 + ], + "lines": [ + { + "bbox": [ + 105, + 263, + 293, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 293, + 277 + ], + "score": 1.0, + "content": "This paper makes the following contributions:", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9, + "bbox_fs": [ + 105, + 263, + 293, + 277 + ] + }, + { + "type": "list", + "bbox": [ + 129, + 284, + 505, + 405 + ], + "lines": [ + { + "bbox": [ + 130, + 284, + 505, + 297 + ], + "spans": [ + { + "bbox": [ + 130, + 284, + 505, + 297 + ], + "score": 1.0, + "content": "1. It reveals a fundamental limitation of GAIL by showing that discriminators do in practice", + "type": "text" + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 295, + 458, + 308 + ], + "spans": [ + { + "bbox": [ + 141, + 295, + 458, + 308 + ], + "score": 1.0, + "content": "exploit task-irrelevant information, thereby resulting in poor task performance.", + "type": "text" + } + ], + "index": 11, + "is_list_end_line": true + }, + { + "bbox": [ + 129, + 308, + 505, + 322 + ], + "spans": [ + { + "bbox": [ + 129, + 308, + 505, + 322 + ], + "score": 1.0, + "content": "2. It introduces powerful GAIL baselines. In particular, it shows that standard regularization", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 142, + 321, + 455, + 333 + ], + "spans": [ + { + "bbox": [ + 142, + 321, + 455, + 333 + ], + "score": 1.0, + "content": "and data augmentation are generally useful and improve upon standard GAIL.", + "type": "text" + } + ], + "index": 13, + "is_list_end_line": true + }, + { + "bbox": [ + 128, + 334, + 505, + 348 + ], + "spans": [ + { + "bbox": [ + 128, + 334, + 505, + 348 + ], + "score": 1.0, + "content": "3. It shows that these improvements to GAIL, as well as other improvements proposed by", + "type": "text" + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 345, + 505, + 360 + ], + "spans": [ + { + "bbox": [ + 141, + 345, + 505, + 360 + ], + "score": 1.0, + "content": "Reed et al. (2018), do not completely solve the problem, allowing GAIL agents to fail", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 357, + 395, + 369 + ], + "spans": [ + { + "bbox": [ + 141, + 357, + 395, + 369 + ], + "score": 1.0, + "content": "catastrophically with the addition of task-irrelevant distractors.", + "type": "text" + } + ], + "index": 16, + "is_list_end_line": true + }, + { + "bbox": [ + 129, + 371, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 129, + 371, + 505, + 384 + ], + "score": 1.0, + "content": "4. It introduces Task Relevant Adversarial Imitation Learning (TRAIL), using constrained", + "type": "text" + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 142, + 382, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 142, + 382, + 505, + 394 + ], + "score": 1.0, + "content": "optimization to force the discriminator to focus on the relevant aspects of the task, which", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 393, + 485, + 407 + ], + "spans": [ + { + "bbox": [ + 141, + 393, + 485, + 407 + ], + "score": 1.0, + "content": "improves performance dramatically on manipulation tasks from pixels (see Figure 1).", + "type": "text" + } + ], + "index": 19, + "is_list_end_line": true + } + ], + "index": 14.5, + "bbox_fs": [ + 128, + 284, + 505, + 407 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 420, + 209, + 432 + ], + "lines": [ + { + "bbox": [ + 105, + 419, + 211, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 211, + 434 + ], + "score": 1.0, + "content": "2 RELATED WORK", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 444, + 505, + 478 + ], + "lines": [ + { + "bbox": [ + 105, + 444, + 506, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 506, + 457 + ], + "score": 1.0, + "content": "The use of demonstrations to help agent training has been studied extensively in robotics (Bakker", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 455, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 505, + 468 + ], + "score": 1.0, + "content": "& Kuniyoshi, 1996; Kawato et al., 1994; Miyamoto et al., 1996) with approaches ranging from", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 466, + 401, + 479 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 401, + 479 + ], + "score": 1.0, + "content": "Q-learning (Schaal, 1997) to behavioral cloning (BC) (Pomerleau, 1989).", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22, + "bbox_fs": [ + 105, + 444, + 506, + 479 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 483, + 505, + 549 + ], + "lines": [ + { + "bbox": [ + 105, + 483, + 505, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 505, + 496 + ], + "score": 1.0, + "content": "BC: BC is effective in solving many control problems (Pomerleau, 1989; Finn et al., 2017; Duan", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 493, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 505, + 507 + ], + "score": 1.0, + "content": "et al., 2017; Rahmatizadeh et al., 2018). It has also been successfully applied to initialize RL training", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 505, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 505, + 518 + ], + "score": 1.0, + "content": "(Rajeswaran et al., 2017). It, however, suffers from compounding errors as initial small deviations", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 516, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 505, + 529 + ], + "score": 1.0, + "content": "from the expert behaviors tend to cause bigger differences (Ross et al., 2011). This often necessitates", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 528, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 106, + 528, + 505, + 540 + ], + "score": 1.0, + "content": "a large number of demonstrations for satisfactory performance. Furthermore, BC typically does not", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 538, + 323, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 323, + 550 + ], + "score": 1.0, + "content": "lead to agents that are superior to their demonstrators.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 483, + 505, + 550 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 555, + 505, + 610 + ], + "lines": [ + { + "bbox": [ + 105, + 554, + 506, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 238, + 568 + ], + "score": 1.0, + "content": "Inverse RL: Ziebart et al. (2008);", + "type": "text" + }, + { + "bbox": [ + 239, + 555, + 253, + 567 + ], + "score": 0.43, + "content": "\\mathrm { N g }", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 554, + 343, + 568 + ], + "score": 1.0, + "content": "et al. (2000); Abbeel &", + "type": "text" + }, + { + "bbox": [ + 343, + 555, + 385, + 567 + ], + "score": 0.33, + "content": "\\mathrm { N g } \\left( 2 0 0 4 \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 554, + 506, + 568 + ], + "score": 1.0, + "content": "propose inverse reinforcement", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 564, + 505, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 505, + 580 + ], + "score": 1.0, + "content": "learning (IRL) as a way of learning reward functions from demonstrations. Reinforcement learning", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 578, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 106, + 578, + 505, + 590 + ], + "score": 1.0, + "content": "can then be used to optimize that learned reward. Recently, Finn et al. (2016b) approached continuous", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 586, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 505, + 603 + ], + "score": 1.0, + "content": "robotic control problems with success by applying Maximum Entropy IRL algorithms which are very", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 599, + 397, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 397, + 612 + ], + "score": 1.0, + "content": "closely related to GAIL (Finn et al., 2016a) and have similar drawbacks.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32, + "bbox_fs": [ + 105, + 554, + 506, + 612 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 615, + 505, + 671 + ], + "lines": [ + { + "bbox": [ + 105, + 615, + 507, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 507, + 629 + ], + "score": 1.0, + "content": "Learning from Demonstrations: Hester et al. (2018) developed deep Q-Learning from demonstra-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "score": 1.0, + "content": "tion (DQfD), in which expert trajectories are added to experience replay and jointly used to train", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 638, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 506, + 651 + ], + "score": 1.0, + "content": "agents along with their own experiences. This was later extended by Vecerik et al. (2017) and Pohlen", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "et al. (2018) to better handle sparse-reward problems in control and Atari games respectively. Despite", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 660, + 449, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 449, + 673 + ], + "score": 1.0, + "content": "their efficiency, this class of methods still requires access to rewards in order to learn.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 37, + "bbox_fs": [ + 105, + 615, + 507, + 673 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "score": 1.0, + "content": "GAIL: Following the success of Generative Adversarial Networks (Goodfellow et al., 2014) in image", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 687, + 507, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 507, + 701 + ], + "score": 1.0, + "content": "generation, GAIL (Ho & Ermon, 2016) applies adversarial learning to the problem of imitation.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "Although many variants are introduced in the literature (Li et al., 2017; Fu et al., 2018; Merel et al.,", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 708, + 507, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 507, + 723 + ], + "score": 1.0, + "content": "2017; Zhu et al., 2018; Baram et al., 2017), making GAIL work for high-dimensional input spaces,", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 720, + 284, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 284, + 734 + ], + "score": 1.0, + "content": "particularly raw pixels, remains a challenge.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 42, + "bbox_fs": [ + 105, + 676, + 507, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 171 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "A few papers (Peng et al., 2018; Reed et al., 2018; Blondé & Kalousis, 2018) seek to address the", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 94, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 506, + 106 + ], + "score": 1.0, + "content": "problem of overfitting the discriminator. Peng et al. (2018) introduces the Variational Bottleneck", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "to regularize the discriminator. Reed et al. (2018) proposes to not train the vision module of the", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 506, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 506, + 128 + ], + "score": 1.0, + "content": "discriminator (e.g. use the vision module of the critic network instead) and only train a tiny network", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 127, + 506, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 127, + 506, + 138 + ], + "score": 1.0, + "content": "on top of the vision module to discriminate. Blondé & Kalousis (2018) follow a similar approach.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 137, + 506, + 150 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 506, + 150 + ], + "score": 1.0, + "content": "Unstructured regularization, however, cannot stop the discriminator from fitting to features that are", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 148, + 506, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 506, + 161 + ], + "score": 1.0, + "content": "systematically different between the agents’ and the demonstration’s behavior, like those illustrated", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 465, + 172 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 465, + 172 + ], + "score": 1.0, + "content": "in Figure 2. TRAIL, on the other hand, is much less prone to overfitting to these features.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 176, + 505, + 231 + ], + "lines": [ + { + "bbox": [ + 106, + 176, + 505, + 188 + ], + "spans": [ + { + "bbox": [ + 106, + 176, + 505, + 188 + ], + "score": 1.0, + "content": "Stadie et al. (2017) extend GAIL to the setting of third person imitation, in which the demonstrator and", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "score": 1.0, + "content": "agent observations come from different views. To prevent the discriminator from discriminating based", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 506, + 210 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 506, + 210 + ], + "score": 1.0, + "content": "on viewpoint domain, they use gradient flipping from an auxiliary classifier to learn domain-invariant", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 210, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 210, + 505, + 222 + ], + "score": 1.0, + "content": "features. Our approach is not to learn domain-invariant features, but instead learn domain-agnostic", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 220, + 279, + 233 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 279, + 233 + ], + "score": 1.0, + "content": "discriminators that only focus on behavior.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 237, + 505, + 270 + ], + "lines": [ + { + "bbox": [ + 106, + 237, + 506, + 249 + ], + "spans": [ + { + "bbox": [ + 106, + 237, + 506, + 249 + ], + "score": 1.0, + "content": "Several recent works have focused on improving the sample efficiency of GAIL (Blondé & Kalousis,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 246, + 505, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 505, + 261 + ], + "score": 1.0, + "content": "2018; Sasaki et al., 2018). Common to these approaches and to this work, is the use of off-policy", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 259, + 471, + 272 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 471, + 272 + ], + "score": 1.0, + "content": "actor critic agents and experience replay, to improve the utilization of available experience.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14 + }, + { + "type": "title", + "bbox": [ + 108, + 293, + 434, + 306 + ], + "lines": [ + { + "bbox": [ + 104, + 292, + 437, + 308 + ], + "spans": [ + { + "bbox": [ + 104, + 292, + 437, + 308 + ], + "score": 1.0, + "content": "3 REINFORCEMENT LEARNING AND ADVERSARIAL IMITATION", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 322, + 505, + 400 + ], + "lines": [ + { + "bbox": [ + 105, + 322, + 505, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 505, + 335 + ], + "score": 1.0, + "content": "Following the notation of Sutton & Barto (2018), a Markov Decision Process (MDP) is a tuple", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 333, + 506, + 347 + ], + "spans": [ + { + "bbox": [ + 106, + 333, + 167, + 345 + ], + "score": 0.91, + "content": "( \\mathcal { S } , \\mathcal { A } , R , \\mathbf { \\bar { P } } , \\gamma )", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 333, + 213, + 347 + ], + "score": 1.0, + "content": "with states", + "type": "text" + }, + { + "bbox": [ + 214, + 334, + 222, + 344 + ], + "score": 0.78, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 333, + 257, + 347 + ], + "score": 1.0, + "content": ", actions", + "type": "text" + }, + { + "bbox": [ + 257, + 334, + 266, + 343 + ], + "score": 0.81, + "content": "\\mathcal { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 266, + 333, + 336, + 347 + ], + "score": 1.0, + "content": ", reward function", + "type": "text" + }, + { + "bbox": [ + 337, + 334, + 367, + 345 + ], + "score": 0.93, + "content": "R ( s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 333, + 461, + 347 + ], + "score": 1.0, + "content": ", transition distribution", + "type": "text" + }, + { + "bbox": [ + 461, + 334, + 502, + 345 + ], + "score": 0.92, + "content": "P ( s ^ { \\prime } | s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 333, + 506, + 347 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 344, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 160, + 358 + ], + "score": 1.0, + "content": "and discount", + "type": "text" + }, + { + "bbox": [ + 160, + 347, + 168, + 356 + ], + "score": 0.82, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 344, + 243, + 358 + ], + "score": 1.0, + "content": ". An agent in state", + "type": "text" + }, + { + "bbox": [ + 243, + 345, + 268, + 355 + ], + "score": 0.9, + "content": "s \\in S", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 344, + 320, + 358 + ], + "score": 1.0, + "content": "takes action", + "type": "text" + }, + { + "bbox": [ + 320, + 345, + 346, + 355 + ], + "score": 0.9, + "content": "a \\in A", + "type": "inline_equation" + }, + { + "bbox": [ + 346, + 344, + 440, + 358 + ], + "score": 1.0, + "content": "according to its policy", + "type": "text" + }, + { + "bbox": [ + 440, + 347, + 448, + 354 + ], + "score": 0.74, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 344, + 506, + 358 + ], + "score": 1.0, + "content": "and moves to", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 354, + 506, + 369 + ], + "spans": [ + { + "bbox": [ + 104, + 354, + 128, + 369 + ], + "score": 1.0, + "content": "state", + "type": "text" + }, + { + "bbox": [ + 128, + 355, + 156, + 366 + ], + "score": 0.91, + "content": "s ^ { \\prime } \\in \\varDelta", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 354, + 506, + 369 + ], + "score": 1.0, + "content": "according to the transition distribution. The goal of RL algorithms is to find a policy", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 366, + 505, + 379 + ], + "spans": [ + { + "bbox": [ + 106, + 366, + 505, + 379 + ], + "score": 1.0, + "content": "that maximizes the expected sum of discounted rewards, represented by the action value function", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 375, + 504, + 394 + ], + "spans": [ + { + "bbox": [ + 106, + 377, + 246, + 390 + ], + "score": 0.91, + "content": "\\begin{array} { r } { Q ^ { \\pi } ( s , a ) = \\mathbb { E } ^ { \\pi } [ \\sum _ { t = 0 } ^ { \\infty } \\overset { \\cdot } { \\gamma } ^ { t } R ( s _ { t } , a _ { t } ) ] } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 375, + 275, + 394 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 276, + 378, + 289, + 388 + ], + "score": 0.91, + "content": "\\mathbb { E } ^ { \\pi }", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 375, + 475, + 394 + ], + "score": 1.0, + "content": "is an expectation over trajectories starting from", + "type": "text" + }, + { + "bbox": [ + 476, + 379, + 504, + 388 + ], + "score": 0.86, + "content": "s _ { 0 } = s", + "type": "inline_equation" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 388, + 353, + 402 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 177, + 402 + ], + "score": 1.0, + "content": "and taking action", + "type": "text" + }, + { + "bbox": [ + 178, + 391, + 207, + 399 + ], + "score": 0.89, + "content": "a _ { 0 } = a", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 388, + 341, + 402 + ], + "score": 1.0, + "content": "and thereafter running the policy", + "type": "text" + }, + { + "bbox": [ + 342, + 391, + 348, + 398 + ], + "score": 0.75, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 388, + 353, + 402 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 405, + 505, + 471 + ], + "lines": [ + { + "bbox": [ + 105, + 405, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 505, + 418 + ], + "score": 1.0, + "content": "To apply RL, it is essential that we have access to the reward function which is often hard to design", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 415, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 106, + 415, + 505, + 428 + ], + "score": 1.0, + "content": "and evaluate (Singh et al., 2019). In addition, sparse rewards can cause exploration difficulties that", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 104, + 427, + 506, + 441 + ], + "spans": [ + { + "bbox": [ + 104, + 427, + 506, + 441 + ], + "score": 1.0, + "content": "pose great challenges to RL algorithms. We therefore look to imitation learning and particularly", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 438, + 505, + 451 + ], + "spans": [ + { + "bbox": [ + 106, + 438, + 505, + 451 + ], + "score": 1.0, + "content": "GAIL to derive a reward function from expert demonstrations. In GAIL, a reward function is learned", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 449, + 506, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 450, + 246, + 461 + ], + "score": 1.0, + "content": "by training a discriminator network", + "type": "text" + }, + { + "bbox": [ + 246, + 449, + 278, + 461 + ], + "score": 0.93, + "content": "D ( s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 450, + 506, + 461 + ], + "score": 1.0, + "content": "to distinguish between agent and expert state-action pairs.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 459, + 310, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 310, + 473 + ], + "score": 1.0, + "content": "The GAIL objective is thus formulated as follows:", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 26.5 + }, + { + "type": "interline_equation", + "bbox": [ + 148, + 483, + 461, + 501 + ], + "lines": [ + { + "bbox": [ + 148, + 483, + 461, + 501 + ], + "spans": [ + { + "bbox": [ + 148, + 483, + 461, + 501 + ], + "score": 0.85, + "content": "\\operatorname* { m i n } _ { \\pi } \\operatorname* { m a x } _ { D } \\mathbb { E } _ { ( s , a ) \\sim \\pi _ { E } } [ \\log D ( s , a ) ] + \\mathbb { E } _ { ( s , a ) \\sim \\pi } [ \\log ( 1 - D ( s , a ) ) ] - \\lambda _ { H } H ( \\pi ) ,", + "type": "interline_equation", + "image_path": "108a841f22d52fb14679a7fca453346693df0d23802f2235bfac6b83e1870dfa.jpg" + } + ] + } + ], + "index": 30, + "virtual_lines": [ + { + "bbox": [ + 148, + 483, + 461, + 501 + ], + "spans": [], + "index": 30 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 513, + 505, + 536 + ], + "lines": [ + { + "bbox": [ + 105, + 512, + 505, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 133, + 527 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 516, + 141, + 523 + ], + "score": 0.74, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 512, + 220, + 527 + ], + "score": 1.0, + "content": "is the agent policy,", + "type": "text" + }, + { + "bbox": [ + 220, + 516, + 234, + 524 + ], + "score": 0.85, + "content": "\\pi _ { E }", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 512, + 325, + 527 + ], + "score": 1.0, + "content": "the expert policy, and", + "type": "text" + }, + { + "bbox": [ + 325, + 514, + 348, + 525 + ], + "score": 0.91, + "content": "H ( \\pi )", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 512, + 505, + 527 + ], + "score": 1.0, + "content": "an (optional) entropy regularizer. The", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 523, + 372, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 246, + 537 + ], + "score": 1.0, + "content": "reward function is defined simply:", + "type": "text" + }, + { + "bbox": [ + 246, + 524, + 367, + 537 + ], + "score": 0.91, + "content": "R ( s , a ) = - \\log ( 1 - D ( s , a ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 368, + 523, + 372, + 537 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31.5 + }, + { + "type": "text", + "bbox": [ + 107, + 541, + 505, + 586 + ], + "lines": [ + { + "bbox": [ + 105, + 540, + 506, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 554 + ], + "score": 1.0, + "content": "GAIL is theoretically appealing and practically simple. The discriminator, however, can focus on any", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 552, + 505, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 505, + 564 + ], + "score": 1.0, + "content": "features to discriminate, whether these features are task-relevant or not. In the next subsection we", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 564, + 505, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 505, + 575 + ], + "score": 1.0, + "content": "describe a way to constrain the discriminator network in order to prevent it from using task-irrelevant", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 574, + 281, + 587 + ], + "spans": [ + { + "bbox": [ + 106, + 574, + 281, + 587 + ], + "score": 1.0, + "content": "details to distinguish agent and expert data.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34.5 + }, + { + "type": "title", + "bbox": [ + 105, + 608, + 459, + 622 + ], + "lines": [ + { + "bbox": [ + 104, + 607, + 460, + 624 + ], + "spans": [ + { + "bbox": [ + 104, + 607, + 460, + 624 + ], + "score": 1.0, + "content": "4 TASK-RELEVANT ADVERSARIAL IMITATION LEARNING (TRAIL)", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 637, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 106, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "We want the discriminator to focus on task-relevant features. Our proposed solution, TRAIL, prevents", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "the discriminator from being able to distinguish expert and agent behaviour based on selected aspects", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "of the data. For instance, the discriminator should distinguish agent and expert frames only when", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 671, + 506, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 506, + 683 + ], + "score": 1.0, + "content": "meaningful behavior is present in those frames. In the absence of behavior useful to solve the task,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 681, + 490, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 490, + 694 + ], + "score": 1.0, + "content": "e.g. in initial frames prior to the execution of the behavior, the discriminator should be agnostic.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "To this end, we propose a constraint for the discriminator, such that its accuracy must not be greater", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 298, + 722 + ], + "score": 1.0, + "content": "than chance on a particular set of observations", + "type": "text" + }, + { + "bbox": [ + 298, + 712, + 305, + 720 + ], + "score": 0.87, + "content": "\\mathcal { L }", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 709, + 444, + 722 + ], + "score": 1.0, + "content": "that we will call the invariant set.", + "type": "text" + }, + { + "bbox": [ + 445, + 710, + 453, + 720 + ], + "score": 0.66, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "will include", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "only observations that can be distinguished as agent or expert in task-irrelevant ways. Precisely, we", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 171 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "A few papers (Peng et al., 2018; Reed et al., 2018; Blondé & Kalousis, 2018) seek to address the", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 94, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 506, + 106 + ], + "score": 1.0, + "content": "problem of overfitting the discriminator. Peng et al. (2018) introduces the Variational Bottleneck", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "to regularize the discriminator. Reed et al. (2018) proposes to not train the vision module of the", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 506, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 506, + 128 + ], + "score": 1.0, + "content": "discriminator (e.g. use the vision module of the critic network instead) and only train a tiny network", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 127, + 506, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 127, + 506, + 138 + ], + "score": 1.0, + "content": "on top of the vision module to discriminate. Blondé & Kalousis (2018) follow a similar approach.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 137, + 506, + 150 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 506, + 150 + ], + "score": 1.0, + "content": "Unstructured regularization, however, cannot stop the discriminator from fitting to features that are", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 148, + 506, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 506, + 161 + ], + "score": 1.0, + "content": "systematically different between the agents’ and the demonstration’s behavior, like those illustrated", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 465, + 172 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 465, + 172 + ], + "score": 1.0, + "content": "in Figure 2. TRAIL, on the other hand, is much less prone to overfitting to these features.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 82, + 506, + 172 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 176, + 505, + 231 + ], + "lines": [ + { + "bbox": [ + 106, + 176, + 505, + 188 + ], + "spans": [ + { + "bbox": [ + 106, + 176, + 505, + 188 + ], + "score": 1.0, + "content": "Stadie et al. (2017) extend GAIL to the setting of third person imitation, in which the demonstrator and", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "score": 1.0, + "content": "agent observations come from different views. To prevent the discriminator from discriminating based", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 506, + 210 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 506, + 210 + ], + "score": 1.0, + "content": "on viewpoint domain, they use gradient flipping from an auxiliary classifier to learn domain-invariant", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 210, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 210, + 505, + 222 + ], + "score": 1.0, + "content": "features. Our approach is not to learn domain-invariant features, but instead learn domain-agnostic", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 220, + 279, + 233 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 279, + 233 + ], + "score": 1.0, + "content": "discriminators that only focus on behavior.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10, + "bbox_fs": [ + 105, + 176, + 506, + 233 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 237, + 505, + 270 + ], + "lines": [ + { + "bbox": [ + 106, + 237, + 506, + 249 + ], + "spans": [ + { + "bbox": [ + 106, + 237, + 506, + 249 + ], + "score": 1.0, + "content": "Several recent works have focused on improving the sample efficiency of GAIL (Blondé & Kalousis,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 246, + 505, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 505, + 261 + ], + "score": 1.0, + "content": "2018; Sasaki et al., 2018). Common to these approaches and to this work, is the use of off-policy", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 259, + 471, + 272 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 471, + 272 + ], + "score": 1.0, + "content": "actor critic agents and experience replay, to improve the utilization of available experience.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14, + "bbox_fs": [ + 105, + 237, + 506, + 272 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 293, + 434, + 306 + ], + "lines": [ + { + "bbox": [ + 104, + 292, + 437, + 308 + ], + "spans": [ + { + "bbox": [ + 104, + 292, + 437, + 308 + ], + "score": 1.0, + "content": "3 REINFORCEMENT LEARNING AND ADVERSARIAL IMITATION", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 322, + 505, + 400 + ], + "lines": [ + { + "bbox": [ + 105, + 322, + 505, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 505, + 335 + ], + "score": 1.0, + "content": "Following the notation of Sutton & Barto (2018), a Markov Decision Process (MDP) is a tuple", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 333, + 506, + 347 + ], + "spans": [ + { + "bbox": [ + 106, + 333, + 167, + 345 + ], + "score": 0.91, + "content": "( \\mathcal { S } , \\mathcal { A } , R , \\mathbf { \\bar { P } } , \\gamma )", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 333, + 213, + 347 + ], + "score": 1.0, + "content": "with states", + "type": "text" + }, + { + "bbox": [ + 214, + 334, + 222, + 344 + ], + "score": 0.78, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 333, + 257, + 347 + ], + "score": 1.0, + "content": ", actions", + "type": "text" + }, + { + "bbox": [ + 257, + 334, + 266, + 343 + ], + "score": 0.81, + "content": "\\mathcal { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 266, + 333, + 336, + 347 + ], + "score": 1.0, + "content": ", reward function", + "type": "text" + }, + { + "bbox": [ + 337, + 334, + 367, + 345 + ], + "score": 0.93, + "content": "R ( s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 333, + 461, + 347 + ], + "score": 1.0, + "content": ", transition distribution", + "type": "text" + }, + { + "bbox": [ + 461, + 334, + 502, + 345 + ], + "score": 0.92, + "content": "P ( s ^ { \\prime } | s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 333, + 506, + 347 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 344, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 160, + 358 + ], + "score": 1.0, + "content": "and discount", + "type": "text" + }, + { + "bbox": [ + 160, + 347, + 168, + 356 + ], + "score": 0.82, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 344, + 243, + 358 + ], + "score": 1.0, + "content": ". An agent in state", + "type": "text" + }, + { + "bbox": [ + 243, + 345, + 268, + 355 + ], + "score": 0.9, + "content": "s \\in S", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 344, + 320, + 358 + ], + "score": 1.0, + "content": "takes action", + "type": "text" + }, + { + "bbox": [ + 320, + 345, + 346, + 355 + ], + "score": 0.9, + "content": "a \\in A", + "type": "inline_equation" + }, + { + "bbox": [ + 346, + 344, + 440, + 358 + ], + "score": 1.0, + "content": "according to its policy", + "type": "text" + }, + { + "bbox": [ + 440, + 347, + 448, + 354 + ], + "score": 0.74, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 344, + 506, + 358 + ], + "score": 1.0, + "content": "and moves to", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 354, + 506, + 369 + ], + "spans": [ + { + "bbox": [ + 104, + 354, + 128, + 369 + ], + "score": 1.0, + "content": "state", + "type": "text" + }, + { + "bbox": [ + 128, + 355, + 156, + 366 + ], + "score": 0.91, + "content": "s ^ { \\prime } \\in \\varDelta", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 354, + 506, + 369 + ], + "score": 1.0, + "content": "according to the transition distribution. The goal of RL algorithms is to find a policy", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 366, + 505, + 379 + ], + "spans": [ + { + "bbox": [ + 106, + 366, + 505, + 379 + ], + "score": 1.0, + "content": "that maximizes the expected sum of discounted rewards, represented by the action value function", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 375, + 504, + 394 + ], + "spans": [ + { + "bbox": [ + 106, + 377, + 246, + 390 + ], + "score": 0.91, + "content": "\\begin{array} { r } { Q ^ { \\pi } ( s , a ) = \\mathbb { E } ^ { \\pi } [ \\sum _ { t = 0 } ^ { \\infty } \\overset { \\cdot } { \\gamma } ^ { t } R ( s _ { t } , a _ { t } ) ] } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 375, + 275, + 394 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 276, + 378, + 289, + 388 + ], + "score": 0.91, + "content": "\\mathbb { E } ^ { \\pi }", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 375, + 475, + 394 + ], + "score": 1.0, + "content": "is an expectation over trajectories starting from", + "type": "text" + }, + { + "bbox": [ + 476, + 379, + 504, + 388 + ], + "score": 0.86, + "content": "s _ { 0 } = s", + "type": "inline_equation" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 388, + 353, + 402 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 177, + 402 + ], + "score": 1.0, + "content": "and taking action", + "type": "text" + }, + { + "bbox": [ + 178, + 391, + 207, + 399 + ], + "score": 0.89, + "content": "a _ { 0 } = a", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 388, + 341, + 402 + ], + "score": 1.0, + "content": "and thereafter running the policy", + "type": "text" + }, + { + "bbox": [ + 342, + 391, + 348, + 398 + ], + "score": 0.75, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 388, + 353, + 402 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20, + "bbox_fs": [ + 104, + 322, + 506, + 402 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 405, + 505, + 471 + ], + "lines": [ + { + "bbox": [ + 105, + 405, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 505, + 418 + ], + "score": 1.0, + "content": "To apply RL, it is essential that we have access to the reward function which is often hard to design", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 415, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 106, + 415, + 505, + 428 + ], + "score": 1.0, + "content": "and evaluate (Singh et al., 2019). In addition, sparse rewards can cause exploration difficulties that", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 104, + 427, + 506, + 441 + ], + "spans": [ + { + "bbox": [ + 104, + 427, + 506, + 441 + ], + "score": 1.0, + "content": "pose great challenges to RL algorithms. We therefore look to imitation learning and particularly", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 438, + 505, + 451 + ], + "spans": [ + { + "bbox": [ + 106, + 438, + 505, + 451 + ], + "score": 1.0, + "content": "GAIL to derive a reward function from expert demonstrations. In GAIL, a reward function is learned", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 449, + 506, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 450, + 246, + 461 + ], + "score": 1.0, + "content": "by training a discriminator network", + "type": "text" + }, + { + "bbox": [ + 246, + 449, + 278, + 461 + ], + "score": 0.93, + "content": "D ( s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 450, + 506, + 461 + ], + "score": 1.0, + "content": "to distinguish between agent and expert state-action pairs.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 459, + 310, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 310, + 473 + ], + "score": 1.0, + "content": "The GAIL objective is thus formulated as follows:", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 26.5, + "bbox_fs": [ + 104, + 405, + 506, + 473 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 148, + 483, + 461, + 501 + ], + "lines": [ + { + "bbox": [ + 148, + 483, + 461, + 501 + ], + "spans": [ + { + "bbox": [ + 148, + 483, + 461, + 501 + ], + "score": 0.85, + "content": "\\operatorname* { m i n } _ { \\pi } \\operatorname* { m a x } _ { D } \\mathbb { E } _ { ( s , a ) \\sim \\pi _ { E } } [ \\log D ( s , a ) ] + \\mathbb { E } _ { ( s , a ) \\sim \\pi } [ \\log ( 1 - D ( s , a ) ) ] - \\lambda _ { H } H ( \\pi ) ,", + "type": "interline_equation", + "image_path": "108a841f22d52fb14679a7fca453346693df0d23802f2235bfac6b83e1870dfa.jpg" + } + ] + } + ], + "index": 30, + "virtual_lines": [ + { + "bbox": [ + 148, + 483, + 461, + 501 + ], + "spans": [], + "index": 30 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 513, + 505, + 536 + ], + "lines": [ + { + "bbox": [ + 105, + 512, + 505, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 133, + 527 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 516, + 141, + 523 + ], + "score": 0.74, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 512, + 220, + 527 + ], + "score": 1.0, + "content": "is the agent policy,", + "type": "text" + }, + { + "bbox": [ + 220, + 516, + 234, + 524 + ], + "score": 0.85, + "content": "\\pi _ { E }", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 512, + 325, + 527 + ], + "score": 1.0, + "content": "the expert policy, and", + "type": "text" + }, + { + "bbox": [ + 325, + 514, + 348, + 525 + ], + "score": 0.91, + "content": "H ( \\pi )", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 512, + 505, + 527 + ], + "score": 1.0, + "content": "an (optional) entropy regularizer. The", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 523, + 372, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 246, + 537 + ], + "score": 1.0, + "content": "reward function is defined simply:", + "type": "text" + }, + { + "bbox": [ + 246, + 524, + 367, + 537 + ], + "score": 0.91, + "content": "R ( s , a ) = - \\log ( 1 - D ( s , a ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 368, + 523, + 372, + 537 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31.5, + "bbox_fs": [ + 105, + 512, + 505, + 537 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 541, + 505, + 586 + ], + "lines": [ + { + "bbox": [ + 105, + 540, + 506, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 554 + ], + "score": 1.0, + "content": "GAIL is theoretically appealing and practically simple. The discriminator, however, can focus on any", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 552, + 505, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 505, + 564 + ], + "score": 1.0, + "content": "features to discriminate, whether these features are task-relevant or not. In the next subsection we", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 564, + 505, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 505, + 575 + ], + "score": 1.0, + "content": "describe a way to constrain the discriminator network in order to prevent it from using task-irrelevant", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 574, + 281, + 587 + ], + "spans": [ + { + "bbox": [ + 106, + 574, + 281, + 587 + ], + "score": 1.0, + "content": "details to distinguish agent and expert data.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 540, + 506, + 587 + ] + }, + { + "type": "title", + "bbox": [ + 105, + 608, + 459, + 622 + ], + "lines": [ + { + "bbox": [ + 104, + 607, + 460, + 624 + ], + "spans": [ + { + "bbox": [ + 104, + 607, + 460, + 624 + ], + "score": 1.0, + "content": "4 TASK-RELEVANT ADVERSARIAL IMITATION LEARNING (TRAIL)", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 637, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 106, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "We want the discriminator to focus on task-relevant features. Our proposed solution, TRAIL, prevents", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "the discriminator from being able to distinguish expert and agent behaviour based on selected aspects", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "of the data. For instance, the discriminator should distinguish agent and expert frames only when", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 671, + 506, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 506, + 683 + ], + "score": 1.0, + "content": "meaningful behavior is present in those frames. In the absence of behavior useful to solve the task,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 681, + 490, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 490, + 694 + ], + "score": 1.0, + "content": "e.g. in initial frames prior to the execution of the behavior, the discriminator should be agnostic.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40, + "bbox_fs": [ + 105, + 637, + 506, + 694 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "To this end, we propose a constraint for the discriminator, such that its accuracy must not be greater", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 298, + 722 + ], + "score": 1.0, + "content": "than chance on a particular set of observations", + "type": "text" + }, + { + "bbox": [ + 298, + 712, + 305, + 720 + ], + "score": 0.87, + "content": "\\mathcal { L }", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 709, + 444, + 722 + ], + "score": 1.0, + "content": "that we will call the invariant set.", + "type": "text" + }, + { + "bbox": [ + 445, + 710, + 453, + 720 + ], + "score": 0.66, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "will include", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "only observations that can be distinguished as agent or expert in task-irrelevant ways. Precisely, we", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 80, + 421, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 421, + 97 + ], + "score": 1.0, + "content": "formulate TRAIL in terms of the following constrained optimization problem:", + "type": "text", + "cross_page": true + } + ], + "index": 0 + } + ], + "index": 44, + "bbox_fs": [ + 105, + 698, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 420, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 421, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 421, + 97 + ], + "score": 1.0, + "content": "formulate TRAIL in terms of the following constrained optimization problem:", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "interline_equation", + "bbox": [ + 156, + 98, + 455, + 145 + ], + "lines": [ + { + "bbox": [ + 156, + 98, + 455, + 145 + ], + "spans": [ + { + "bbox": [ + 156, + 98, + 455, + 145 + ], + "score": 0.93, + "content": "\\begin{array} { r l } { \\displaystyle \\mathop { \\operatorname* { m a x } } _ { \\psi } } & { \\mathbb { E } _ { s \\sim \\pi _ { E } } \\left[ \\log D _ { \\psi } ( s ) \\right] + \\mathbb { E } _ { s \\sim \\pi _ { \\theta } } \\left[ \\log ( 1 - D _ { \\psi } ( s ) ) \\right] } \\\\ { \\displaystyle s . t . } & { \\frac { 1 } { 2 } \\mathbb { E } _ { s \\sim \\pi _ { E } } \\left[ { \\mathbf 1 } _ { { \\mathbf D } _ { \\psi } ( { \\mathbf s } ) \\geq \\frac { 1 } { 2 } } \\mid s \\in { \\mathbb Z } \\right] + \\frac { 1 } { 2 } \\mathbb { E } _ { s \\sim \\pi _ { \\theta } } \\left[ { \\mathbf 1 } _ { { \\mathbf D } _ { \\psi } ( { \\mathbf s } ) < \\frac { 1 } { 2 } } \\mid s \\in { \\mathbb Z } \\right] \\le \\frac { 1 } { 2 } . } \\end{array}", + "type": "interline_equation", + "image_path": "677a3c547cb7740be31ef7ad9de87cb3fd4d4b0088c73a1397ca4bd2fd8ee8c4.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 156, + 98, + 455, + 113.66666666666667 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 156, + 113.66666666666667, + 455, + 129.33333333333334 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 156, + 129.33333333333334, + 455, + 145.0 + ], + "spans": [], + "index": 3 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 154, + 504, + 187 + ], + "lines": [ + { + "bbox": [ + 105, + 153, + 503, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 495, + 167 + ], + "score": 1.0, + "content": "To apply the above constraint in practice, we can optimize the reverse of the objective function on", + "type": "text" + }, + { + "bbox": [ + 496, + 154, + 503, + 163 + ], + "score": 0.81, + "content": "\\mathcal { T }", + "type": "inline_equation" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 164, + 506, + 177 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 203, + 177 + ], + "score": 1.0, + "content": "That is, given a batch of", + "type": "text" + }, + { + "bbox": [ + 204, + 165, + 214, + 174 + ], + "score": 0.86, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 164, + 254, + 177 + ], + "score": 1.0, + "content": "examples", + "type": "text" + }, + { + "bbox": [ + 254, + 166, + 327, + 176 + ], + "score": 0.49, + "content": "s _ { e } \\sim \\pi _ { E } , s _ { \\theta } \\sim \\pi _ { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 328, + 164, + 451, + 177 + ], + "score": 1.0, + "content": "from the expert and agent, and", + "type": "text" + }, + { + "bbox": [ + 451, + 165, + 487, + 176 + ], + "score": 0.92, + "content": "\\hat { s } _ { e } \\sim \\pi _ { E }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 164, + 506, + 177 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 107, + 176, + 446, + 188 + ], + "spans": [ + { + "bbox": [ + 107, + 176, + 140, + 187 + ], + "score": 0.91, + "content": "\\hat { s } _ { \\theta } \\sim \\pi _ { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 176, + 200, + 188 + ], + "score": 1.0, + "content": "both in the set", + "type": "text" + }, + { + "bbox": [ + 200, + 176, + 208, + 186 + ], + "score": 0.8, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 176, + 446, + 188 + ], + "score": 1.0, + "content": ", we maximize the following augmented objective function:", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5 + }, + { + "type": "interline_equation", + "bbox": [ + 119, + 191, + 491, + 237 + ], + "lines": [ + { + "bbox": [ + 119, + 191, + 491, + 237 + ], + "spans": [ + { + "bbox": [ + 119, + 191, + 491, + 237 + ], + "score": 0.93, + "content": "\\begin{array} { r l } & { \\mathcal { L } _ { \\psi } \\big ( s _ { e } , s _ { \\theta } , \\hat { s } _ { e } , \\hat { s } _ { \\theta } \\big ) = \\sum _ { i = 1 } ^ { N } \\log D _ { \\psi } \\left( s _ { e } ^ { ( i ) } \\right) + \\log \\left( 1 - D _ { \\psi } \\left( s _ { \\theta } ^ { ( i ) } \\right) \\right) } \\\\ & { \\qquad - \\lambda \\left[ \\sum _ { i = 1 } ^ { N } \\log D _ { \\psi } \\left( \\hat { s } _ { e } ^ { ( i ) } \\right) + \\log \\left( 1 - D _ { \\psi } \\left( \\hat { s } _ { \\theta } ^ { ( i ) } \\right) \\right) \\right] \\mathbf { 1 } _ { a c c u r a c y ( \\hat { s } _ { e } , \\hat { s } _ { \\theta } ) \\geq \\frac { 1 } { 2 } } , } \\end{array}", + "type": "interline_equation", + "image_path": "4d4c40cd8a255e2543089e2861ddce6e8fe5af859ebd3aa65fb0b438c9523f44.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 119, + 191, + 491, + 206.33333333333334 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 119, + 206.33333333333334, + 491, + 221.66666666666669 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 119, + 221.66666666666669, + 491, + 237.00000000000003 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 240, + 405, + 253 + ], + "lines": [ + { + "bbox": [ + 105, + 240, + 406, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 240, + 133, + 254 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 241, + 191, + 253 + ], + "score": 0.31, + "content": "a c c u r a c y ( \\cdot , \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 191, + 240, + 406, + 254 + ], + "score": 1.0, + "content": "is defined as the average of discriminator accuracies:", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "interline_equation", + "bbox": [ + 182, + 257, + 428, + 292 + ], + "lines": [ + { + "bbox": [ + 182, + 257, + 428, + 292 + ], + "spans": [ + { + "bbox": [ + 182, + 257, + 428, + 292 + ], + "score": 0.94, + "content": "a c c u r a c y ( \\hat { s } _ { e } , \\hat { s } _ { \\theta } ) = \\frac { 1 } { 2 N } \\sum _ { i = 1 } ^ { N } \\left[ \\mathbf { 1 } _ { \\mathrm { D } _ { \\psi } \\left( \\hat { \\mathbf { s } } _ { e } ^ { ( \\mathrm { i } ) } \\right) \\geq \\frac { 1 } { 2 } } + \\mathbf { 1 } _ { \\mathrm { D } _ { \\psi } \\left( \\hat { \\mathbf { s } } _ { \\theta } ^ { ( \\mathrm { i } ) } \\right) < \\frac { 1 } { 2 } } \\right] .", + "type": "interline_equation", + "image_path": "d4fae644884feb2b3543a804ce727543c012afad257cd167eb5487d306ecc872.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 182, + 257, + 428, + 268.6666666666667 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 182, + 268.6666666666667, + 428, + 280.33333333333337 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 182, + 280.33333333333337, + 428, + 292.00000000000006 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 296, + 290, + 308 + ], + "lines": [ + { + "bbox": [ + 105, + 295, + 291, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 150, + 311 + ], + "score": 1.0, + "content": "The scalar", + "type": "text" + }, + { + "bbox": [ + 150, + 297, + 175, + 308 + ], + "score": 0.9, + "content": "\\lambda \\geq 0", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 295, + 291, + 311 + ], + "score": 1.0, + "content": "is a tunable hyperparameter.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 313, + 505, + 347 + ], + "lines": [ + { + "bbox": [ + 105, + 312, + 507, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 312, + 507, + 327 + ], + "score": 1.0, + "content": "We used single frames as states but sequences can also be used, and we do not require expert actions.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "Not requiring actions enables learning in very off-policy settings, where the action dimensions and", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 335, + 490, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 490, + 348 + ], + "score": 1.0, + "content": "distributions of the demonstrator (another robot or human) are different from those of the agent.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16 + }, + { + "type": "title", + "bbox": [ + 107, + 360, + 302, + 372 + ], + "lines": [ + { + "bbox": [ + 105, + 361, + 303, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 303, + 373 + ], + "score": 1.0, + "content": "4.1 THE SELECTION OF THE INVARIANT SET", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 381, + 505, + 425 + ], + "lines": [ + { + "bbox": [ + 105, + 380, + 506, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 243, + 394 + ], + "score": 1.0, + "content": "The selection of the invariant set", + "type": "text" + }, + { + "bbox": [ + 243, + 382, + 251, + 391 + ], + "score": 0.8, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 251, + 380, + 506, + 394 + ], + "score": 1.0, + "content": "is a design choice. In general, we could always contrive non-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 391, + 506, + 406 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 506, + 406 + ], + "score": 1.0, + "content": "stationary and adversarial ways of making this choice difficult. However, we argue that in many", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 403, + 506, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 506, + 416 + ], + "score": 1.0, + "content": "situations of great interest, including our robotic manipulation setup, it is easy to propose effective", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 415, + 233, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 415, + 233, + 426 + ], + "score": 1.0, + "content": "and very general invariant sets.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 107, + 430, + 505, + 497 + ], + "lines": [ + { + "bbox": [ + 106, + 431, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 106, + 431, + 505, + 443 + ], + "score": 1.0, + "content": "A straightforward way to collect robot data is to execute a random policy. We can then use the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 442, + 505, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 430, + 454 + ], + "score": 1.0, + "content": "resulting random episodes, for both expert and agent, to construct the invariant set", + "type": "text" + }, + { + "bbox": [ + 430, + 442, + 438, + 452 + ], + "score": 0.59, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 442, + 505, + 454 + ], + "score": 1.0, + "content": ". Another way to", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 145, + 466 + ], + "score": 1.0, + "content": "construct", + "type": "text" + }, + { + "bbox": [ + 146, + 453, + 154, + 463 + ], + "score": 0.79, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 154, + 453, + 506, + 466 + ], + "score": 1.0, + "content": "is to use early frames from both expert and agent episodes. Since in early frames little", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 463, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 505, + 476 + ], + "score": 1.0, + "content": "or no task behavior is apparent, this strategy turns out to be effective and no extra data has to be", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 475, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 106, + 475, + 506, + 488 + ], + "score": 1.0, + "content": "collected. This strategy also improves robustness with respect to variation in the initial conditions of", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 486, + 330, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 486, + 330, + 498 + ], + "score": 1.0, + "content": "the task; see for example block insertion in Figure 1(d).", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 108, + 502, + 505, + 536 + ], + "lines": [ + { + "bbox": [ + 107, + 503, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 107, + 503, + 198, + 515 + ], + "score": 1.0, + "content": "Importantly, if the set", + "type": "text" + }, + { + "bbox": [ + 198, + 503, + 206, + 513 + ], + "score": 0.75, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 207, + 503, + 505, + 515 + ], + "score": 1.0, + "content": "captures some forms of irrelevance but not all forms, it will nonetheless", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 514, + 506, + 527 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 506, + 527 + ], + "score": 1.0, + "content": "always help in improving performance. In this regard, TRAIL will dominate its GAIL predecessor", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 525, + 468, + 537 + ], + "spans": [ + { + "bbox": [ + 106, + 525, + 468, + 537 + ], + "score": 1.0, + "content": "whenever the designer has some prior on what aspects of the data might be task irrelevant.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30 + }, + { + "type": "title", + "bbox": [ + 108, + 552, + 200, + 564 + ], + "lines": [ + { + "bbox": [ + 105, + 552, + 201, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 201, + 566 + ], + "score": 1.0, + "content": "5 EXPERIMENTS", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 577, + 505, + 633 + ], + "lines": [ + { + "bbox": [ + 106, + 577, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 106, + 577, + 505, + 590 + ], + "score": 1.0, + "content": "We focus on solving robot manipulation tasks. The environment implements two work-spaces: one", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 586, + 505, + 602 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 505, + 602 + ], + "score": 1.0, + "content": "with a Kinova Jaco arm (Jaco), and the other with a Sawyer arm (Sawyer). See supplementary", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "material A.1 for a detailed description. Environment rewards, which are not used by GAIL-based", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 610, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 239, + 622 + ], + "score": 1.0, + "content": "methods, are sparse and equal to", + "type": "text" + }, + { + "bbox": [ + 239, + 610, + 251, + 620 + ], + "score": 0.84, + "content": "+ 1", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 610, + 505, + 622 + ], + "score": 1.0, + "content": "for each step when a given task is solved and 0 otherwise. The", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 622, + 483, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 622, + 483, + 633 + ], + "score": 1.0, + "content": "maximum reward for the episode is 200, since this is the length of a single evaluation episode.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 637, + 504, + 682 + ], + "lines": [ + { + "bbox": [ + 105, + 638, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 506, + 651 + ], + "score": 1.0, + "content": "Our agent is based on the off-policy D4PG algorithm (Barth-Maron et al., 2018) because of its", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 648, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 661 + ], + "score": 1.0, + "content": "stability and data-efficiency (see supplementary material A.6). Following Vecerik et al. (2017), we", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 660, + 506, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 506, + 673 + ], + "score": 1.0, + "content": "add expert demonstrations into the agents’ experience replay, and refer to the resulting RL algorithm", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 671, + 491, + 683 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 491, + 683 + ], + "score": 1.0, + "content": "as D4PG from Demonstrations (D4PGfD). For each task we collect 100 human demonstrations.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 39.5 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "Data augmentation Traditional data augmentation has proved beneficial in imitation learning", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "(Berseth & Pal, 2019). Surprisingly, to the best of our knowledge, this has not been explicitly", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "studied in prior publications on GAIL. However, we find that data augmentation is a generally useful", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 721, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 506, + 733 + ], + "score": 1.0, + "content": "component to prevent discriminator overfitting. It drastically improves the baseline GAIL agent, and", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43.5 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 26, + 308, + 38 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 308, + 39 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 308, + 39 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 759 + ], + "lines": [] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 420, + 94 + ], + "lines": [], + "index": 0, + "bbox_fs": [ + 105, + 80, + 421, + 97 + ], + "lines_deleted": true + }, + { + "type": "interline_equation", + "bbox": [ + 156, + 98, + 455, + 145 + ], + "lines": [ + { + "bbox": [ + 156, + 98, + 455, + 145 + ], + "spans": [ + { + "bbox": [ + 156, + 98, + 455, + 145 + ], + "score": 0.93, + "content": "\\begin{array} { r l } { \\displaystyle \\mathop { \\operatorname* { m a x } } _ { \\psi } } & { \\mathbb { E } _ { s \\sim \\pi _ { E } } \\left[ \\log D _ { \\psi } ( s ) \\right] + \\mathbb { E } _ { s \\sim \\pi _ { \\theta } } \\left[ \\log ( 1 - D _ { \\psi } ( s ) ) \\right] } \\\\ { \\displaystyle s . t . } & { \\frac { 1 } { 2 } \\mathbb { E } _ { s \\sim \\pi _ { E } } \\left[ { \\mathbf 1 } _ { { \\mathbf D } _ { \\psi } ( { \\mathbf s } ) \\geq \\frac { 1 } { 2 } } \\mid s \\in { \\mathbb Z } \\right] + \\frac { 1 } { 2 } \\mathbb { E } _ { s \\sim \\pi _ { \\theta } } \\left[ { \\mathbf 1 } _ { { \\mathbf D } _ { \\psi } ( { \\mathbf s } ) < \\frac { 1 } { 2 } } \\mid s \\in { \\mathbb Z } \\right] \\le \\frac { 1 } { 2 } . } \\end{array}", + "type": "interline_equation", + "image_path": "677a3c547cb7740be31ef7ad9de87cb3fd4d4b0088c73a1397ca4bd2fd8ee8c4.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 156, + 98, + 455, + 113.66666666666667 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 156, + 113.66666666666667, + 455, + 129.33333333333334 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 156, + 129.33333333333334, + 455, + 145.0 + ], + "spans": [], + "index": 3 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 154, + 504, + 187 + ], + "lines": [ + { + "bbox": [ + 105, + 153, + 503, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 495, + 167 + ], + "score": 1.0, + "content": "To apply the above constraint in practice, we can optimize the reverse of the objective function on", + "type": "text" + }, + { + "bbox": [ + 496, + 154, + 503, + 163 + ], + "score": 0.81, + "content": "\\mathcal { T }", + "type": "inline_equation" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 164, + 506, + 177 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 203, + 177 + ], + "score": 1.0, + "content": "That is, given a batch of", + "type": "text" + }, + { + "bbox": [ + 204, + 165, + 214, + 174 + ], + "score": 0.86, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 164, + 254, + 177 + ], + "score": 1.0, + "content": "examples", + "type": "text" + }, + { + "bbox": [ + 254, + 166, + 327, + 176 + ], + "score": 0.49, + "content": "s _ { e } \\sim \\pi _ { E } , s _ { \\theta } \\sim \\pi _ { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 328, + 164, + 451, + 177 + ], + "score": 1.0, + "content": "from the expert and agent, and", + "type": "text" + }, + { + "bbox": [ + 451, + 165, + 487, + 176 + ], + "score": 0.92, + "content": "\\hat { s } _ { e } \\sim \\pi _ { E }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 164, + 506, + 177 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 107, + 176, + 446, + 188 + ], + "spans": [ + { + "bbox": [ + 107, + 176, + 140, + 187 + ], + "score": 0.91, + "content": "\\hat { s } _ { \\theta } \\sim \\pi _ { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 176, + 200, + 188 + ], + "score": 1.0, + "content": "both in the set", + "type": "text" + }, + { + "bbox": [ + 200, + 176, + 208, + 186 + ], + "score": 0.8, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 176, + 446, + 188 + ], + "score": 1.0, + "content": ", we maximize the following augmented objective function:", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5, + "bbox_fs": [ + 105, + 153, + 506, + 188 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 119, + 191, + 491, + 237 + ], + "lines": [ + { + "bbox": [ + 119, + 191, + 491, + 237 + ], + "spans": [ + { + "bbox": [ + 119, + 191, + 491, + 237 + ], + "score": 0.93, + "content": "\\begin{array} { r l } & { \\mathcal { L } _ { \\psi } \\big ( s _ { e } , s _ { \\theta } , \\hat { s } _ { e } , \\hat { s } _ { \\theta } \\big ) = \\sum _ { i = 1 } ^ { N } \\log D _ { \\psi } \\left( s _ { e } ^ { ( i ) } \\right) + \\log \\left( 1 - D _ { \\psi } \\left( s _ { \\theta } ^ { ( i ) } \\right) \\right) } \\\\ & { \\qquad - \\lambda \\left[ \\sum _ { i = 1 } ^ { N } \\log D _ { \\psi } \\left( \\hat { s } _ { e } ^ { ( i ) } \\right) + \\log \\left( 1 - D _ { \\psi } \\left( \\hat { s } _ { \\theta } ^ { ( i ) } \\right) \\right) \\right] \\mathbf { 1 } _ { a c c u r a c y ( \\hat { s } _ { e } , \\hat { s } _ { \\theta } ) \\geq \\frac { 1 } { 2 } } , } \\end{array}", + "type": "interline_equation", + "image_path": "4d4c40cd8a255e2543089e2861ddce6e8fe5af859ebd3aa65fb0b438c9523f44.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 119, + 191, + 491, + 206.33333333333334 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 119, + 206.33333333333334, + 491, + 221.66666666666669 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 119, + 221.66666666666669, + 491, + 237.00000000000003 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 240, + 405, + 253 + ], + "lines": [ + { + "bbox": [ + 105, + 240, + 406, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 240, + 133, + 254 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 241, + 191, + 253 + ], + "score": 0.31, + "content": "a c c u r a c y ( \\cdot , \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 191, + 240, + 406, + 254 + ], + "score": 1.0, + "content": "is defined as the average of discriminator accuracies:", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10, + "bbox_fs": [ + 105, + 240, + 406, + 254 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 182, + 257, + 428, + 292 + ], + "lines": [ + { + "bbox": [ + 182, + 257, + 428, + 292 + ], + "spans": [ + { + "bbox": [ + 182, + 257, + 428, + 292 + ], + "score": 0.94, + "content": "a c c u r a c y ( \\hat { s } _ { e } , \\hat { s } _ { \\theta } ) = \\frac { 1 } { 2 N } \\sum _ { i = 1 } ^ { N } \\left[ \\mathbf { 1 } _ { \\mathrm { D } _ { \\psi } \\left( \\hat { \\mathbf { s } } _ { e } ^ { ( \\mathrm { i } ) } \\right) \\geq \\frac { 1 } { 2 } } + \\mathbf { 1 } _ { \\mathrm { D } _ { \\psi } \\left( \\hat { \\mathbf { s } } _ { \\theta } ^ { ( \\mathrm { i } ) } \\right) < \\frac { 1 } { 2 } } \\right] .", + "type": "interline_equation", + "image_path": "d4fae644884feb2b3543a804ce727543c012afad257cd167eb5487d306ecc872.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 182, + 257, + 428, + 268.6666666666667 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 182, + 268.6666666666667, + 428, + 280.33333333333337 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 182, + 280.33333333333337, + 428, + 292.00000000000006 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 296, + 290, + 308 + ], + "lines": [ + { + "bbox": [ + 105, + 295, + 291, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 150, + 311 + ], + "score": 1.0, + "content": "The scalar", + "type": "text" + }, + { + "bbox": [ + 150, + 297, + 175, + 308 + ], + "score": 0.9, + "content": "\\lambda \\geq 0", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 295, + 291, + 311 + ], + "score": 1.0, + "content": "is a tunable hyperparameter.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14, + "bbox_fs": [ + 105, + 295, + 291, + 311 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 313, + 505, + 347 + ], + "lines": [ + { + "bbox": [ + 105, + 312, + 507, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 312, + 507, + 327 + ], + "score": 1.0, + "content": "We used single frames as states but sequences can also be used, and we do not require expert actions.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "Not requiring actions enables learning in very off-policy settings, where the action dimensions and", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 335, + 490, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 490, + 348 + ], + "score": 1.0, + "content": "distributions of the demonstrator (another robot or human) are different from those of the agent.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16, + "bbox_fs": [ + 105, + 312, + 507, + 348 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 360, + 302, + 372 + ], + "lines": [ + { + "bbox": [ + 105, + 361, + 303, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 303, + 373 + ], + "score": 1.0, + "content": "4.1 THE SELECTION OF THE INVARIANT SET", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 381, + 505, + 425 + ], + "lines": [ + { + "bbox": [ + 105, + 380, + 506, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 243, + 394 + ], + "score": 1.0, + "content": "The selection of the invariant set", + "type": "text" + }, + { + "bbox": [ + 243, + 382, + 251, + 391 + ], + "score": 0.8, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 251, + 380, + 506, + 394 + ], + "score": 1.0, + "content": "is a design choice. In general, we could always contrive non-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 391, + 506, + 406 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 506, + 406 + ], + "score": 1.0, + "content": "stationary and adversarial ways of making this choice difficult. However, we argue that in many", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 403, + 506, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 506, + 416 + ], + "score": 1.0, + "content": "situations of great interest, including our robotic manipulation setup, it is easy to propose effective", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 415, + 233, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 415, + 233, + 426 + ], + "score": 1.0, + "content": "and very general invariant sets.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5, + "bbox_fs": [ + 105, + 380, + 506, + 426 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 430, + 505, + 497 + ], + "lines": [ + { + "bbox": [ + 106, + 431, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 106, + 431, + 505, + 443 + ], + "score": 1.0, + "content": "A straightforward way to collect robot data is to execute a random policy. We can then use the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 442, + 505, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 430, + 454 + ], + "score": 1.0, + "content": "resulting random episodes, for both expert and agent, to construct the invariant set", + "type": "text" + }, + { + "bbox": [ + 430, + 442, + 438, + 452 + ], + "score": 0.59, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 442, + 505, + 454 + ], + "score": 1.0, + "content": ". Another way to", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 145, + 466 + ], + "score": 1.0, + "content": "construct", + "type": "text" + }, + { + "bbox": [ + 146, + 453, + 154, + 463 + ], + "score": 0.79, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 154, + 453, + 506, + 466 + ], + "score": 1.0, + "content": "is to use early frames from both expert and agent episodes. Since in early frames little", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 463, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 505, + 476 + ], + "score": 1.0, + "content": "or no task behavior is apparent, this strategy turns out to be effective and no extra data has to be", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 475, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 106, + 475, + 506, + 488 + ], + "score": 1.0, + "content": "collected. This strategy also improves robustness with respect to variation in the initial conditions of", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 486, + 330, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 486, + 330, + 498 + ], + "score": 1.0, + "content": "the task; see for example block insertion in Figure 1(d).", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 25.5, + "bbox_fs": [ + 105, + 431, + 506, + 498 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 502, + 505, + 536 + ], + "lines": [ + { + "bbox": [ + 107, + 503, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 107, + 503, + 198, + 515 + ], + "score": 1.0, + "content": "Importantly, if the set", + "type": "text" + }, + { + "bbox": [ + 198, + 503, + 206, + 513 + ], + "score": 0.75, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 207, + 503, + 505, + 515 + ], + "score": 1.0, + "content": "captures some forms of irrelevance but not all forms, it will nonetheless", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 514, + 506, + 527 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 506, + 527 + ], + "score": 1.0, + "content": "always help in improving performance. In this regard, TRAIL will dominate its GAIL predecessor", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 525, + 468, + 537 + ], + "spans": [ + { + "bbox": [ + 106, + 525, + 468, + 537 + ], + "score": 1.0, + "content": "whenever the designer has some prior on what aspects of the data might be task irrelevant.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30, + "bbox_fs": [ + 106, + 503, + 506, + 537 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 552, + 200, + 564 + ], + "lines": [ + { + "bbox": [ + 105, + 552, + 201, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 201, + 566 + ], + "score": 1.0, + "content": "5 EXPERIMENTS", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 577, + 505, + 633 + ], + "lines": [ + { + "bbox": [ + 106, + 577, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 106, + 577, + 505, + 590 + ], + "score": 1.0, + "content": "We focus on solving robot manipulation tasks. The environment implements two work-spaces: one", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 586, + 505, + 602 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 505, + 602 + ], + "score": 1.0, + "content": "with a Kinova Jaco arm (Jaco), and the other with a Sawyer arm (Sawyer). See supplementary", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "material A.1 for a detailed description. Environment rewards, which are not used by GAIL-based", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 610, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 239, + 622 + ], + "score": 1.0, + "content": "methods, are sparse and equal to", + "type": "text" + }, + { + "bbox": [ + 239, + 610, + 251, + 620 + ], + "score": 0.84, + "content": "+ 1", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 610, + 505, + 622 + ], + "score": 1.0, + "content": "for each step when a given task is solved and 0 otherwise. The", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 622, + 483, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 622, + 483, + 633 + ], + "score": 1.0, + "content": "maximum reward for the episode is 200, since this is the length of a single evaluation episode.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 577, + 505, + 633 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 637, + 504, + 682 + ], + "lines": [ + { + "bbox": [ + 105, + 638, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 506, + 651 + ], + "score": 1.0, + "content": "Our agent is based on the off-policy D4PG algorithm (Barth-Maron et al., 2018) because of its", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 648, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 661 + ], + "score": 1.0, + "content": "stability and data-efficiency (see supplementary material A.6). Following Vecerik et al. (2017), we", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 660, + 506, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 506, + 673 + ], + "score": 1.0, + "content": "add expert demonstrations into the agents’ experience replay, and refer to the resulting RL algorithm", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 671, + 491, + 683 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 491, + 683 + ], + "score": 1.0, + "content": "as D4PG from Demonstrations (D4PGfD). For each task we collect 100 human demonstrations.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 39.5, + "bbox_fs": [ + 105, + 638, + 506, + 683 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "Data augmentation Traditional data augmentation has proved beneficial in imitation learning", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "(Berseth & Pal, 2019). Surprisingly, to the best of our knowledge, this has not been explicitly", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "studied in prior publications on GAIL. However, we find that data augmentation is a generally useful", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 721, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 506, + 733 + ], + "score": 1.0, + "content": "component to prevent discriminator overfitting. It drastically improves the baseline GAIL agent, and", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "is necessary to solve any of the harder manipulation tasks. We distort images by randomly changing", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "score": 1.0, + "content": "brightness, contrast and saturation; random cropping and rotation; adding Gaussian noise. When", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 506, + 118 + ], + "score": 1.0, + "content": "multiple sensor inputs are available (e.g. multiple cameras), we also randomly drop out these inputs,", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 229, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 229, + 128 + ], + "score": 1.0, + "content": "but leaving at least one active.", + "type": "text", + "cross_page": true + } + ], + "index": 3 + } + ], + "index": 43.5, + "bbox_fs": [ + 105, + 687, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 126 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "is necessary to solve any of the harder manipulation tasks. We distort images by randomly changing", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "score": 1.0, + "content": "brightness, contrast and saturation; random cropping and rotation; adding Gaussian noise. When", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 506, + 118 + ], + "score": 1.0, + "content": "multiple sensor inputs are available (e.g. multiple cameras), we also randomly drop out these inputs,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 229, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 229, + 128 + ], + "score": 1.0, + "content": "but leaving at least one active.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "text", + "bbox": [ + 107, + 132, + 505, + 187 + ], + "lines": [ + { + "bbox": [ + 106, + 131, + 505, + 145 + ], + "spans": [ + { + "bbox": [ + 106, + 131, + 505, + 145 + ], + "score": 1.0, + "content": "All discriminator-based methods in this work (including all baselines) use data augmentation except", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 143, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 106, + 143, + 505, + 156 + ], + "score": 1.0, + "content": "as indicated in the relevant ablations (see Section 5.2). We also considered regularizing the GAIL", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "score": 1.0, + "content": "discriminator with spectral normalization (Miyato et al., 2018). It performed slightly better than", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 164, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 505, + 178 + ], + "score": 1.0, + "content": "GAIL, but still failed in the presence of distractor objects, and we thus omit spectral normalization in", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 174, + 253, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 174, + 253, + 190 + ], + "score": 1.0, + "content": "the main experiments for simplicity.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 193, + 505, + 226 + ], + "lines": [ + { + "bbox": [ + 105, + 192, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 206 + ], + "score": 1.0, + "content": "Actor early stopping When the agent has learned the desired behavior, and the resulting data is used", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 204, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 204, + 505, + 216 + ], + "score": 1.0, + "content": "for training, the discriminator will become unable to distinguish expert and agent observations based", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 214, + 448, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 448, + 227 + ], + "score": 1.0, + "content": "only on behavior. This forces the discriminator to rely on task-irrelevant information.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 232, + 505, + 310 + ], + "lines": [ + { + "bbox": [ + 105, + 232, + 504, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 504, + 244 + ], + "score": 1.0, + "content": "To avoid this scenario, we propose to restart each actor episode after a certain number of steps", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 243, + 506, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 506, + 255 + ], + "score": 1.0, + "content": "such that successful behavior is rarely represented in agent data. This enables the discriminator to", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 253, + 506, + 268 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 506, + 268 + ], + "score": 1.0, + "content": "recognize the goal condition, which appears frequently at the end of demonstration episodes, as", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 264, + 506, + 278 + ], + "spans": [ + { + "bbox": [ + 104, + 264, + 506, + 278 + ], + "score": 1.0, + "content": "representative of expert behavior. To avoid hand-tuning the stopping step number, we found that the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 275, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 505, + 289 + ], + "score": 1.0, + "content": "discriminator score can be used to derive an adaptive stopping criterion. Concretely, we restart an", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 287, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 506, + 299 + ], + "score": 1.0, + "content": "episode if the discriminator score at the current step exceeds the median score of the episode so far", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 297, + 375, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 120, + 312 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 121, + 298, + 158, + 310 + ], + "score": 0.88, + "content": "T _ { p a t i e n c e }", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 297, + 306, + 312 + ], + "score": 1.0, + "content": "consecutive steps (in practice we set", + "type": "text" + }, + { + "bbox": [ + 307, + 298, + 368, + 310 + ], + "score": 0.91, + "content": "T _ { p a t i e n c e } = 1 0", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 297, + 375, + 312 + ], + "score": 1.0, + "content": ").", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 107, + 315, + 505, + 348 + ], + "lines": [ + { + "bbox": [ + 106, + 315, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 315, + 250, + 327 + ], + "score": 1.0, + "content": "We set invariant set hyperparameter", + "type": "text" + }, + { + "bbox": [ + 250, + 315, + 276, + 325 + ], + "score": 0.9, + "content": "\\lambda = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 315, + 505, + 327 + ], + "score": 1.0, + "content": "and use adaptive early stopping for TRAIL. The ablation", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 325, + 505, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 126, + 338 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 127, + 326, + 152, + 336 + ], + "score": 0.87, + "content": "\\lambda = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 325, + 505, + 338 + ], + "score": 1.0, + "content": ", i.e. adaptive early stopping only, is referred to as TRAIL-0. Hence, the only difference", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 336, + 411, + 348 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 411, + 348 + ], + "score": 1.0, + "content": "between TRAIL-0 and TRAIL is that the later uses invariant set constraints.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20 + }, + { + "type": "title", + "bbox": [ + 108, + 362, + 286, + 373 + ], + "lines": [ + { + "bbox": [ + 106, + 362, + 288, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 362, + 288, + 375 + ], + "score": 1.0, + "content": "5.1 BLOCK LIFTING WITH DISTRACTORS", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 382, + 506, + 416 + ], + "lines": [ + { + "bbox": [ + 105, + 383, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 505, + 394 + ], + "score": 1.0, + "content": "In this section, we consider two variants of the lift task in the Sawyer work space: a) lift alone, where", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 394, + 506, + 406 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 506, + 406 + ], + "score": 1.0, + "content": "only one red cube is present, b) lift distracted, with two extra blocks (blue and green, see Figure 9).", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 404, + 425, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 425, + 417 + ], + "score": 1.0, + "content": "We show how adding these additional distractors affects the training procedure.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 107, + 421, + 505, + 465 + ], + "lines": [ + { + "bbox": [ + 105, + 421, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 505, + 434 + ], + "score": 1.0, + "content": "We first compare our method to baselines. In doing so, the invariant set is constructed using the first", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 432, + 506, + 445 + ], + "spans": [ + { + "bbox": [ + 105, + 432, + 506, + 445 + ], + "score": 1.0, + "content": "10 frames from every episode, as in the rest of the work. This choice does not require us to collect", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 444, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 505, + 455 + ], + "score": 1.0, + "content": "any extra data, and hence the comparison with baselines is fair. In the next section, we elaborate on", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 454, + 403, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 403, + 466 + ], + "score": 1.0, + "content": "the choice of the invariant set and provide additional experimental results.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 106, + 471, + 505, + 560 + ], + "lines": [ + { + "bbox": [ + 105, + 471, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 506, + 484 + ], + "score": 1.0, + "content": "As baselines, we run BC and GAIL (with data augmentation). Baseline GAIL is the strongest we", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 483, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 494 + ], + "score": 1.0, + "content": "were able to implement. The only difference between this baseline and TRAIL is the use of invariant", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 493, + 506, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 506, + 506 + ], + "score": 1.0, + "content": "set constrains and actor early stopping (code, agent configurations like number of actors, and network", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 505, + 505, + 517 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 505, + 517 + ], + "score": 1.0, + "content": "architecture are the same). We additionally consider the approaches proposed by Reed et al. (2018) as", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 515, + 506, + 527 + ], + "spans": [ + { + "bbox": [ + 106, + 515, + 506, + 527 + ], + "score": 1.0, + "content": "GAIL-based baselines; using either a randomly initialized convolutional network, or a convolutional", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 527, + 506, + 538 + ], + "spans": [ + { + "bbox": [ + 106, + 527, + 506, + 538 + ], + "score": 1.0, + "content": "critic network, to provide fixed vision features on top of which a tiny discriminator network is trained.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 536, + 506, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 506, + 550 + ], + "score": 1.0, + "content": "We call these two baselines random and critic respectively. Finally, to show the importance of actor", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 549, + 273, + 561 + ], + "spans": [ + { + "bbox": [ + 106, + 549, + 273, + 561 + ], + "score": 1.0, + "content": "early stopping, we run TRAIL-0 (Fig. 3).", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 33.5 + }, + { + "type": "image", + "bbox": [ + 117, + 567, + 489, + 662 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 117, + 567, + 489, + 662 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 117, + 567, + 489, + 662 + ], + "spans": [ + { + "bbox": [ + 117, + 567, + 489, + 662 + ], + "score": 0.967, + "type": "image", + "image_path": "59bb3bff9b0dfb40d7b0e4e3cc9fbc548f0f04232c09b94486607c7ff7cfd013.jpg" + } + ] + } + ], + "index": 39, + "virtual_lines": [ + { + "bbox": [ + 117, + 567, + 489, + 598.6666666666666 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 117, + 598.6666666666666, + 489, + 630.3333333333333 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 117, + 630.3333333333333, + 489, + 661.9999999999999 + ], + "spans": [], + "index": 40 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 115, + 668, + 492, + 680 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 118, + 666, + 492, + 681 + ], + "spans": [ + { + "bbox": [ + 118, + 666, + 492, + 681 + ], + "score": 1.0, + "content": "Figure 3: Results for lift alone, lift distracted, and lift distracted seeded. Only TRAIL excels.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + } + ], + "index": 40.0 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "All methods perform satisfactorily on lift alone, but the proposed methods TRAIL-0 and TRAIL do", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "best. As expected, the performance of BC on lift distracted is similar to its performance on lift alone,", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 710, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 721 + ], + "score": 1.0, + "content": "despite the two additional blocks. The two additional blocks in lift distracted affect the GAIL-based", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 721, + 289, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 289, + 732 + ], + "score": 1.0, + "content": "baselines, despite being irrelevant to the task.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43.5 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 126 + ], + "lines": [], + "index": 1.5, + "bbox_fs": [ + 105, + 82, + 506, + 128 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 132, + 505, + 187 + ], + "lines": [ + { + "bbox": [ + 106, + 131, + 505, + 145 + ], + "spans": [ + { + "bbox": [ + 106, + 131, + 505, + 145 + ], + "score": 1.0, + "content": "All discriminator-based methods in this work (including all baselines) use data augmentation except", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 143, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 106, + 143, + 505, + 156 + ], + "score": 1.0, + "content": "as indicated in the relevant ablations (see Section 5.2). We also considered regularizing the GAIL", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "score": 1.0, + "content": "discriminator with spectral normalization (Miyato et al., 2018). It performed slightly better than", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 164, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 505, + 178 + ], + "score": 1.0, + "content": "GAIL, but still failed in the presence of distractor objects, and we thus omit spectral normalization in", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 174, + 253, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 174, + 253, + 190 + ], + "score": 1.0, + "content": "the main experiments for simplicity.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6, + "bbox_fs": [ + 105, + 131, + 505, + 190 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 193, + 505, + 226 + ], + "lines": [ + { + "bbox": [ + 105, + 192, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 206 + ], + "score": 1.0, + "content": "Actor early stopping When the agent has learned the desired behavior, and the resulting data is used", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 204, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 204, + 505, + 216 + ], + "score": 1.0, + "content": "for training, the discriminator will become unable to distinguish expert and agent observations based", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 214, + 448, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 448, + 227 + ], + "score": 1.0, + "content": "only on behavior. This forces the discriminator to rely on task-irrelevant information.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10, + "bbox_fs": [ + 105, + 192, + 505, + 227 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 232, + 505, + 310 + ], + "lines": [ + { + "bbox": [ + 105, + 232, + 504, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 504, + 244 + ], + "score": 1.0, + "content": "To avoid this scenario, we propose to restart each actor episode after a certain number of steps", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 243, + 506, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 506, + 255 + ], + "score": 1.0, + "content": "such that successful behavior is rarely represented in agent data. This enables the discriminator to", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 253, + 506, + 268 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 506, + 268 + ], + "score": 1.0, + "content": "recognize the goal condition, which appears frequently at the end of demonstration episodes, as", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 264, + 506, + 278 + ], + "spans": [ + { + "bbox": [ + 104, + 264, + 506, + 278 + ], + "score": 1.0, + "content": "representative of expert behavior. To avoid hand-tuning the stopping step number, we found that the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 275, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 505, + 289 + ], + "score": 1.0, + "content": "discriminator score can be used to derive an adaptive stopping criterion. Concretely, we restart an", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 287, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 506, + 299 + ], + "score": 1.0, + "content": "episode if the discriminator score at the current step exceeds the median score of the episode so far", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 297, + 375, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 120, + 312 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 121, + 298, + 158, + 310 + ], + "score": 0.88, + "content": "T _ { p a t i e n c e }", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 297, + 306, + 312 + ], + "score": 1.0, + "content": "consecutive steps (in practice we set", + "type": "text" + }, + { + "bbox": [ + 307, + 298, + 368, + 310 + ], + "score": 0.91, + "content": "T _ { p a t i e n c e } = 1 0", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 297, + 375, + 312 + ], + "score": 1.0, + "content": ").", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15, + "bbox_fs": [ + 104, + 232, + 506, + 312 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 315, + 505, + 348 + ], + "lines": [ + { + "bbox": [ + 106, + 315, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 315, + 250, + 327 + ], + "score": 1.0, + "content": "We set invariant set hyperparameter", + "type": "text" + }, + { + "bbox": [ + 250, + 315, + 276, + 325 + ], + "score": 0.9, + "content": "\\lambda = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 315, + 505, + 327 + ], + "score": 1.0, + "content": "and use adaptive early stopping for TRAIL. The ablation", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 325, + 505, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 126, + 338 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 127, + 326, + 152, + 336 + ], + "score": 0.87, + "content": "\\lambda = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 325, + 505, + 338 + ], + "score": 1.0, + "content": ", i.e. adaptive early stopping only, is referred to as TRAIL-0. Hence, the only difference", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 336, + 411, + 348 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 411, + 348 + ], + "score": 1.0, + "content": "between TRAIL-0 and TRAIL is that the later uses invariant set constraints.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20, + "bbox_fs": [ + 105, + 315, + 505, + 348 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 362, + 286, + 373 + ], + "lines": [ + { + "bbox": [ + 106, + 362, + 288, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 362, + 288, + 375 + ], + "score": 1.0, + "content": "5.1 BLOCK LIFTING WITH DISTRACTORS", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 382, + 506, + 416 + ], + "lines": [ + { + "bbox": [ + 105, + 383, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 505, + 394 + ], + "score": 1.0, + "content": "In this section, we consider two variants of the lift task in the Sawyer work space: a) lift alone, where", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 394, + 506, + 406 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 506, + 406 + ], + "score": 1.0, + "content": "only one red cube is present, b) lift distracted, with two extra blocks (blue and green, see Figure 9).", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 404, + 425, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 425, + 417 + ], + "score": 1.0, + "content": "We show how adding these additional distractors affects the training procedure.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24, + "bbox_fs": [ + 105, + 383, + 506, + 417 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 421, + 505, + 465 + ], + "lines": [ + { + "bbox": [ + 105, + 421, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 505, + 434 + ], + "score": 1.0, + "content": "We first compare our method to baselines. In doing so, the invariant set is constructed using the first", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 432, + 506, + 445 + ], + "spans": [ + { + "bbox": [ + 105, + 432, + 506, + 445 + ], + "score": 1.0, + "content": "10 frames from every episode, as in the rest of the work. This choice does not require us to collect", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 444, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 505, + 455 + ], + "score": 1.0, + "content": "any extra data, and hence the comparison with baselines is fair. In the next section, we elaborate on", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 454, + 403, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 403, + 466 + ], + "score": 1.0, + "content": "the choice of the invariant set and provide additional experimental results.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 421, + 506, + 466 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 471, + 505, + 560 + ], + "lines": [ + { + "bbox": [ + 105, + 471, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 506, + 484 + ], + "score": 1.0, + "content": "As baselines, we run BC and GAIL (with data augmentation). Baseline GAIL is the strongest we", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 483, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 494 + ], + "score": 1.0, + "content": "were able to implement. The only difference between this baseline and TRAIL is the use of invariant", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 493, + 506, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 506, + 506 + ], + "score": 1.0, + "content": "set constrains and actor early stopping (code, agent configurations like number of actors, and network", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 505, + 505, + 517 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 505, + 517 + ], + "score": 1.0, + "content": "architecture are the same). We additionally consider the approaches proposed by Reed et al. (2018) as", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 515, + 506, + 527 + ], + "spans": [ + { + "bbox": [ + 106, + 515, + 506, + 527 + ], + "score": 1.0, + "content": "GAIL-based baselines; using either a randomly initialized convolutional network, or a convolutional", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 527, + 506, + 538 + ], + "spans": [ + { + "bbox": [ + 106, + 527, + 506, + 538 + ], + "score": 1.0, + "content": "critic network, to provide fixed vision features on top of which a tiny discriminator network is trained.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 536, + 506, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 506, + 550 + ], + "score": 1.0, + "content": "We call these two baselines random and critic respectively. Finally, to show the importance of actor", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 549, + 273, + 561 + ], + "spans": [ + { + "bbox": [ + 106, + 549, + 273, + 561 + ], + "score": 1.0, + "content": "early stopping, we run TRAIL-0 (Fig. 3).", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 471, + 506, + 561 + ] + }, + { + "type": "image", + "bbox": [ + 117, + 567, + 489, + 662 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 117, + 567, + 489, + 662 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 117, + 567, + 489, + 662 + ], + "spans": [ + { + "bbox": [ + 117, + 567, + 489, + 662 + ], + "score": 0.967, + "type": "image", + "image_path": "59bb3bff9b0dfb40d7b0e4e3cc9fbc548f0f04232c09b94486607c7ff7cfd013.jpg" + } + ] + } + ], + "index": 39, + "virtual_lines": [ + { + "bbox": [ + 117, + 567, + 489, + 598.6666666666666 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 117, + 598.6666666666666, + 489, + 630.3333333333333 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 117, + 630.3333333333333, + 489, + 661.9999999999999 + ], + "spans": [], + "index": 40 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 115, + 668, + 492, + 680 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 118, + 666, + 492, + 681 + ], + "spans": [ + { + "bbox": [ + 118, + 666, + 492, + 681 + ], + "score": 1.0, + "content": "Figure 3: Results for lift alone, lift distracted, and lift distracted seeded. Only TRAIL excels.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + } + ], + "index": 40.0 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "All methods perform satisfactorily on lift alone, but the proposed methods TRAIL-0 and TRAIL do", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "best. As expected, the performance of BC on lift distracted is similar to its performance on lift alone,", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 710, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 721 + ], + "score": 1.0, + "content": "despite the two additional blocks. The two additional blocks in lift distracted affect the GAIL-based", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 721, + 289, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 289, + 732 + ], + "score": 1.0, + "content": "baselines, despite being irrelevant to the task.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43.5, + "bbox_fs": [ + 105, + 687, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 137 + ], + "lines": [ + { + "bbox": [ + 106, + 83, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 505, + 95 + ], + "score": 1.0, + "content": "To understand this effect, we conducted an additional experiment (lift distracted seeded). Here the", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "initial block positions are randomly drawn from the expert demonstrations. Therefore, it is impossible", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 105, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 505, + 117 + ], + "score": 1.0, + "content": "to discriminate between expert and actor episodes using the first few frames of an episode. Note", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "score": 1.0, + "content": "this initialization procedure is not applied to the evaluation actor, keeping the evaluation scores", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 352, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 352, + 139 + ], + "score": 1.0, + "content": "comparable between lift distracted and lift distracted seeded.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 107, + 143, + 505, + 209 + ], + "lines": [ + { + "bbox": [ + 105, + 142, + 506, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 506, + 156 + ], + "score": 1.0, + "content": "This experiment exposes one major culprit behind the performance degradation of GAIL: memoriza-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 154, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 505, + 167 + ], + "score": 1.0, + "content": "tion. The discriminator can achieve perfect accuracy by memorizing all 100 initial positions from", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "score": 1.0, + "content": "the demonstration set, making the reward function uninformative. By constraining the discriminator,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 176, + 505, + 188 + ], + "spans": [ + { + "bbox": [ + 106, + 176, + 505, + 188 + ], + "score": 1.0, + "content": "TRAIL squeezes out this irrelevant information and succeeds in solving the task in the presence of", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 186, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 505, + 200 + ], + "score": 1.0, + "content": "distractions. TRAIL is the only method that is able to handle the variety of initial cube positions", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 408, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 408, + 211 + ], + "score": 1.0, + "content": "during training, achieving better than expert performance on lift distracted.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 108, + 215, + 505, + 248 + ], + "lines": [ + { + "bbox": [ + 106, + 214, + 506, + 228 + ], + "spans": [ + { + "bbox": [ + 106, + 214, + 506, + 228 + ], + "score": 1.0, + "content": "Interestingly, random performs reasonably on lift distracted. Given random’s strong performance,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 226, + 505, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 226, + 505, + 239 + ], + "score": 1.0, + "content": "we conducted additional experiments to evaluate its effectiveness when trained with adaptive early", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 237, + 410, + 249 + ], + "spans": [ + { + "bbox": [ + 106, + 237, + 410, + 249 + ], + "score": 1.0, + "content": "stopping and present the results in Figure 12 of the supplementary material.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12 + }, + { + "type": "title", + "bbox": [ + 109, + 262, + 272, + 272 + ], + "lines": [ + { + "bbox": [ + 107, + 262, + 273, + 273 + ], + "spans": [ + { + "bbox": [ + 107, + 262, + 264, + 273 + ], + "score": 1.0, + "content": "CONSTRUCTING THE INVARIANT SET", + "type": "text" + }, + { + "bbox": [ + 265, + 262, + 273, + 272 + ], + "score": 0.4, + "content": "\\mathcal { T }", + "type": "inline_equation" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 281, + 506, + 359 + ], + "lines": [ + { + "bbox": [ + 106, + 281, + 506, + 294 + ], + "spans": [ + { + "bbox": [ + 106, + 281, + 506, + 294 + ], + "score": 1.0, + "content": "In the previous subsection, early frames were used to construct the invariant set (TRAIL-early). Here,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 293, + 506, + 305 + ], + "spans": [ + { + "bbox": [ + 106, + 293, + 392, + 305 + ], + "score": 1.0, + "content": "we evaluate another previously mentioned approach for constructing", + "type": "text" + }, + { + "bbox": [ + 392, + 293, + 400, + 302 + ], + "score": 0.69, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 293, + 506, + 305 + ], + "score": 1.0, + "content": "; random policy (TRAIL-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 303, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 506, + 316 + ], + "score": 1.0, + "content": "random). The lift distracted task caused all baselines to fail, but was solved by TRAIL. We introduce", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 315, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 506, + 327 + ], + "score": 1.0, + "content": "a harder version of the task, where the expert appearance is different, to tease out the differences", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "between TRAIL-early and TRAIL-random. The difference in appearance between the expert and", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 336, + 505, + 348 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 505, + 348 + ], + "score": 1.0, + "content": "imitator allows the GAIL discriminator to trivially distinguish them. The results and the differences", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 347, + 310, + 360 + ], + "spans": [ + { + "bbox": [ + 106, + 347, + 310, + 360 + ], + "score": 1.0, + "content": "in the expert appearance are presented in Figure 4.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18 + }, + { + "type": "image", + "bbox": [ + 125, + 371, + 479, + 458 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 125, + 371, + 479, + 458 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 125, + 371, + 479, + 458 + ], + "spans": [ + { + "bbox": [ + 125, + 371, + 479, + 458 + ], + "score": 0.964, + "type": "image", + "image_path": "6b8cf409f166f495f4aaf1c532472a37e5e94c105788ca3abc316459da5a2a6d.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 125, + 371, + 479, + 400.0 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 125, + 400.0, + 479, + 429.0 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 125, + 429.0, + 479, + 458.0 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 464, + 506, + 487 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 464, + 506, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 506, + 476 + ], + "score": 1.0, + "content": "Figure 4: Lift red block, where expert has a different body appearance, and with distractor blocks.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 475, + 411, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 475, + 411, + 487 + ], + "score": 1.0, + "content": "TRAIL-random outperforms GAIL, and performs on par with TRAIL-early.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + } + ], + "index": 24.25 + }, + { + "type": "text", + "bbox": [ + 108, + 499, + 503, + 532 + ], + "lines": [ + { + "bbox": [ + 105, + 497, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 505, + 512 + ], + "score": 1.0, + "content": "The new task is indeed harder and it takes longer for TRAIL methods to achieve performance", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 510, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 510, + 505, + 523 + ], + "score": 1.0, + "content": "better than BC baseline, which is not affected by the different body appearance. GAIL is clearly", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 521, + 251, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 521, + 251, + 532 + ], + "score": 1.0, + "content": "outperformed and does not take off.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 537, + 505, + 604 + ], + "lines": [ + { + "bbox": [ + 105, + 537, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 537, + 505, + 551 + ], + "score": 1.0, + "content": "The difference between TRAIL methods is negligible. We also tried to mix them but the differences", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 549, + 505, + 562 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 505, + 562 + ], + "score": 1.0, + "content": "remain imperceptible. Hence, in the following experiments we simply use early frames. This choice", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 560, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 505, + 573 + ], + "score": 1.0, + "content": "is pragmatic as it does not require that we collect any extra data, and hence the comparison with", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 571, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 571, + 505, + 583 + ], + "score": 1.0, + "content": "GAIL and other baselines is fair. It is also very simple to apply in practice, even if one does not have", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 582, + 505, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 594 + ], + "score": 1.0, + "content": "access to the expert setup anymore. Finally, it is general and powerful enough to be successfully used", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 593, + 352, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 352, + 605 + ], + "score": 1.0, + "content": "across all robotic manipulation tasks considered in this work.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 107, + 610, + 505, + 654 + ], + "lines": [ + { + "bbox": [ + 105, + 610, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 363, + 622 + ], + "score": 1.0, + "content": "To decide how many initial frames should be used to construct", + "type": "text" + }, + { + "bbox": [ + 363, + 610, + 371, + 620 + ], + "score": 0.71, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 371, + 610, + 505, + 622 + ], + "score": 1.0, + "content": ", we conducted an ablation study", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 621, + 506, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 506, + 633 + ], + "score": 1.0, + "content": "and found out that the method is not very sensitive to this choice (see supplementary material A.2).", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 632, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 106, + 632, + 505, + 644 + ], + "score": 1.0, + "content": "Hence, we chose 10 initial frames, and intentionally used the same number for all tasks to further", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 643, + 252, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 643, + 252, + 656 + ], + "score": 1.0, + "content": "emphasize generality of this choice.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 37.5 + }, + { + "type": "title", + "bbox": [ + 108, + 669, + 216, + 680 + ], + "lines": [ + { + "bbox": [ + 106, + 668, + 217, + 681 + ], + "spans": [ + { + "bbox": [ + 106, + 668, + 217, + 681 + ], + "score": 1.0, + "content": "5.2 ABLATION STUDIES", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "title", + "bbox": [ + 107, + 690, + 443, + 701 + ], + "lines": [ + { + "bbox": [ + 107, + 691, + 444, + 701 + ], + "spans": [ + { + "bbox": [ + 107, + 691, + 444, + 701 + ], + "score": 1.0, + "content": "MEASURING DISCRIMINATOR MEMORIZATION OF TASK-IRRELEVANT FEATURES", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 503, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 504, + 722 + ], + "score": 1.0, + "content": "In this section, we experimentally confirm that memorization is a limiting factor of GAIL methods.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "We equipped the discriminator with two extra heads whose inputs are the final spatial layer of the", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 137 + ], + "lines": [ + { + "bbox": [ + 106, + 83, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 505, + 95 + ], + "score": 1.0, + "content": "To understand this effect, we conducted an additional experiment (lift distracted seeded). Here the", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "initial block positions are randomly drawn from the expert demonstrations. Therefore, it is impossible", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 105, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 505, + 117 + ], + "score": 1.0, + "content": "to discriminate between expert and actor episodes using the first few frames of an episode. Note", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "score": 1.0, + "content": "this initialization procedure is not applied to the evaluation actor, keeping the evaluation scores", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 352, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 352, + 139 + ], + "score": 1.0, + "content": "comparable between lift distracted and lift distracted seeded.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2, + "bbox_fs": [ + 105, + 83, + 505, + 139 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 143, + 505, + 209 + ], + "lines": [ + { + "bbox": [ + 105, + 142, + 506, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 506, + 156 + ], + "score": 1.0, + "content": "This experiment exposes one major culprit behind the performance degradation of GAIL: memoriza-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 154, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 505, + 167 + ], + "score": 1.0, + "content": "tion. The discriminator can achieve perfect accuracy by memorizing all 100 initial positions from", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "score": 1.0, + "content": "the demonstration set, making the reward function uninformative. By constraining the discriminator,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 176, + 505, + 188 + ], + "spans": [ + { + "bbox": [ + 106, + 176, + 505, + 188 + ], + "score": 1.0, + "content": "TRAIL squeezes out this irrelevant information and succeeds in solving the task in the presence of", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 186, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 505, + 200 + ], + "score": 1.0, + "content": "distractions. TRAIL is the only method that is able to handle the variety of initial cube positions", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 408, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 408, + 211 + ], + "score": 1.0, + "content": "during training, achieving better than expert performance on lift distracted.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 7.5, + "bbox_fs": [ + 105, + 142, + 506, + 211 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 215, + 505, + 248 + ], + "lines": [ + { + "bbox": [ + 106, + 214, + 506, + 228 + ], + "spans": [ + { + "bbox": [ + 106, + 214, + 506, + 228 + ], + "score": 1.0, + "content": "Interestingly, random performs reasonably on lift distracted. Given random’s strong performance,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 226, + 505, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 226, + 505, + 239 + ], + "score": 1.0, + "content": "we conducted additional experiments to evaluate its effectiveness when trained with adaptive early", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 237, + 410, + 249 + ], + "spans": [ + { + "bbox": [ + 106, + 237, + 410, + 249 + ], + "score": 1.0, + "content": "stopping and present the results in Figure 12 of the supplementary material.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 214, + 506, + 249 + ] + }, + { + "type": "title", + "bbox": [ + 109, + 262, + 272, + 272 + ], + "lines": [ + { + "bbox": [ + 107, + 262, + 273, + 273 + ], + "spans": [ + { + "bbox": [ + 107, + 262, + 264, + 273 + ], + "score": 1.0, + "content": "CONSTRUCTING THE INVARIANT SET", + "type": "text" + }, + { + "bbox": [ + 265, + 262, + 273, + 272 + ], + "score": 0.4, + "content": "\\mathcal { T }", + "type": "inline_equation" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 281, + 506, + 359 + ], + "lines": [ + { + "bbox": [ + 106, + 281, + 506, + 294 + ], + "spans": [ + { + "bbox": [ + 106, + 281, + 506, + 294 + ], + "score": 1.0, + "content": "In the previous subsection, early frames were used to construct the invariant set (TRAIL-early). Here,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 293, + 506, + 305 + ], + "spans": [ + { + "bbox": [ + 106, + 293, + 392, + 305 + ], + "score": 1.0, + "content": "we evaluate another previously mentioned approach for constructing", + "type": "text" + }, + { + "bbox": [ + 392, + 293, + 400, + 302 + ], + "score": 0.69, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 293, + 506, + 305 + ], + "score": 1.0, + "content": "; random policy (TRAIL-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 303, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 506, + 316 + ], + "score": 1.0, + "content": "random). The lift distracted task caused all baselines to fail, but was solved by TRAIL. We introduce", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 315, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 506, + 327 + ], + "score": 1.0, + "content": "a harder version of the task, where the expert appearance is different, to tease out the differences", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "between TRAIL-early and TRAIL-random. The difference in appearance between the expert and", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 336, + 505, + 348 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 505, + 348 + ], + "score": 1.0, + "content": "imitator allows the GAIL discriminator to trivially distinguish them. The results and the differences", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 347, + 310, + 360 + ], + "spans": [ + { + "bbox": [ + 106, + 347, + 310, + 360 + ], + "score": 1.0, + "content": "in the expert appearance are presented in Figure 4.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 281, + 506, + 360 + ] + }, + { + "type": "image", + "bbox": [ + 125, + 371, + 479, + 458 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 125, + 371, + 479, + 458 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 125, + 371, + 479, + 458 + ], + "spans": [ + { + "bbox": [ + 125, + 371, + 479, + 458 + ], + "score": 0.964, + "type": "image", + "image_path": "6b8cf409f166f495f4aaf1c532472a37e5e94c105788ca3abc316459da5a2a6d.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 125, + 371, + 479, + 400.0 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 125, + 400.0, + 479, + 429.0 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 125, + 429.0, + 479, + 458.0 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 464, + 506, + 487 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 464, + 506, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 506, + 476 + ], + "score": 1.0, + "content": "Figure 4: Lift red block, where expert has a different body appearance, and with distractor blocks.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 475, + 411, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 475, + 411, + 487 + ], + "score": 1.0, + "content": "TRAIL-random outperforms GAIL, and performs on par with TRAIL-early.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + } + ], + "index": 24.25 + }, + { + "type": "text", + "bbox": [ + 108, + 499, + 503, + 532 + ], + "lines": [ + { + "bbox": [ + 105, + 497, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 505, + 512 + ], + "score": 1.0, + "content": "The new task is indeed harder and it takes longer for TRAIL methods to achieve performance", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 510, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 510, + 505, + 523 + ], + "score": 1.0, + "content": "better than BC baseline, which is not affected by the different body appearance. GAIL is clearly", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 521, + 251, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 521, + 251, + 532 + ], + "score": 1.0, + "content": "outperformed and does not take off.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28, + "bbox_fs": [ + 105, + 497, + 505, + 532 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 537, + 505, + 604 + ], + "lines": [ + { + "bbox": [ + 105, + 537, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 537, + 505, + 551 + ], + "score": 1.0, + "content": "The difference between TRAIL methods is negligible. We also tried to mix them but the differences", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 549, + 505, + 562 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 505, + 562 + ], + "score": 1.0, + "content": "remain imperceptible. Hence, in the following experiments we simply use early frames. This choice", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 560, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 505, + 573 + ], + "score": 1.0, + "content": "is pragmatic as it does not require that we collect any extra data, and hence the comparison with", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 571, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 571, + 505, + 583 + ], + "score": 1.0, + "content": "GAIL and other baselines is fair. It is also very simple to apply in practice, even if one does not have", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 582, + 505, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 594 + ], + "score": 1.0, + "content": "access to the expert setup anymore. Finally, it is general and powerful enough to be successfully used", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 593, + 352, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 352, + 605 + ], + "score": 1.0, + "content": "across all robotic manipulation tasks considered in this work.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 537, + 505, + 605 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 610, + 505, + 654 + ], + "lines": [ + { + "bbox": [ + 105, + 610, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 363, + 622 + ], + "score": 1.0, + "content": "To decide how many initial frames should be used to construct", + "type": "text" + }, + { + "bbox": [ + 363, + 610, + 371, + 620 + ], + "score": 0.71, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 371, + 610, + 505, + 622 + ], + "score": 1.0, + "content": ", we conducted an ablation study", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 621, + 506, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 506, + 633 + ], + "score": 1.0, + "content": "and found out that the method is not very sensitive to this choice (see supplementary material A.2).", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 632, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 106, + 632, + 505, + 644 + ], + "score": 1.0, + "content": "Hence, we chose 10 initial frames, and intentionally used the same number for all tasks to further", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 643, + 252, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 643, + 252, + 656 + ], + "score": 1.0, + "content": "emphasize generality of this choice.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 37.5, + "bbox_fs": [ + 105, + 610, + 506, + 656 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 669, + 216, + 680 + ], + "lines": [ + { + "bbox": [ + 106, + 668, + 217, + 681 + ], + "spans": [ + { + "bbox": [ + 106, + 668, + 217, + 681 + ], + "score": 1.0, + "content": "5.2 ABLATION STUDIES", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "title", + "bbox": [ + 107, + 690, + 443, + 701 + ], + "lines": [ + { + "bbox": [ + 107, + 691, + 444, + 701 + ], + "spans": [ + { + "bbox": [ + 107, + 691, + 444, + 701 + ], + "score": 1.0, + "content": "MEASURING DISCRIMINATOR MEMORIZATION OF TASK-IRRELEVANT FEATURES", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 503, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 504, + 722 + ], + "score": 1.0, + "content": "In this section, we experimentally confirm that memorization is a limiting factor of GAIL methods.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "We equipped the discriminator with two extra heads whose inputs are the final spatial layer of the", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5, + "bbox_fs": [ + 106, + 709, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 149 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "ResNet for the lift distracted task. The first head is trained on the first frames only, and has the same", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "target as the main head (i.e. discriminating between agent and expert). To train the second head, we", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "randomly divide the expert demonstrations into two equi-numerous subsets, and the task is to predict", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 115, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 505, + 127 + ], + "score": 1.0, + "content": "to which of these randomly chosen sets the demonstration was assigned to. Both heads are trained", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 127, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 127, + 505, + 140 + ], + "score": 1.0, + "content": "via backpropagation but their gradient is not propagated to the ResNet so they do not influence the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 217, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 217, + 150 + ], + "score": 1.0, + "content": "training procedure directly.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 154, + 505, + 209 + ], + "lines": [ + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "score": 1.0, + "content": "If our claim is correct, we expect the extra heads to have higher accuracy for TRAIL-0 as compared", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "score": 1.0, + "content": "to TRAIL, since TRAIL representations are penalized for having features triggering memorization,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 175, + 506, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 175, + 506, + 189 + ], + "score": 1.0, + "content": "i.e. the features should not aid discriminating based on the first frames or predicting a random label", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 506, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 432, + 200 + ], + "score": 1.0, + "content": "for each expert demonstration. No reasonably performing method is able to force", + "type": "text" + }, + { + "bbox": [ + 433, + 187, + 452, + 198 + ], + "score": 0.87, + "content": "50 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 187, + 506, + 200 + ], + "score": 1.0, + "content": "accuracy for", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 494, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 494, + 211 + ], + "score": 1.0, + "content": "extra heads since some features are important to solve the task (e.g. the position of the red cube).", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 215, + 504, + 238 + ], + "lines": [ + { + "bbox": [ + 106, + 214, + 505, + 228 + ], + "spans": [ + { + "bbox": [ + 106, + 214, + 505, + 228 + ], + "score": 1.0, + "content": "We also collected 25 extra holdout demonstrations and visualize the average discriminator prediction", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 227, + 390, + 238 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 390, + 238 + ], + "score": 1.0, + "content": "on them, and compare with predictions on the training demonstrations.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + }, + { + "type": "image", + "bbox": [ + 114, + 251, + 488, + 407 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 114, + 251, + 488, + 407 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 114, + 251, + 488, + 407 + ], + "spans": [ + { + "bbox": [ + 114, + 251, + 488, + 407 + ], + "score": 0.969, + "type": "image", + "image_path": "f3d0ef0720ecd274b57537e078d92668d28a832dccb1c8bad24328a24d337bc8.jpg" + } + ] + } + ], + "index": 14, + "virtual_lines": [ + { + "bbox": [ + 114, + 251, + 488, + 303.0 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 114, + 303.0, + 488, + 355.0 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 114, + 355.0, + 488, + 407.0 + ], + "spans": [], + "index": 15 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 414, + 505, + 470 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 413, + 506, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 506, + 428 + ], + "score": 1.0, + "content": "Figure 5: Demonstrating the memorization problem on the lift distracted task (here higher accuracy", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 424, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 505, + 439 + ], + "score": 1.0, + "content": "is worse). Accuracy of different discriminator heads is presented (A-D). In A, the overall accuracy", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 437, + 505, + 449 + ], + "spans": [ + { + "bbox": [ + 106, + 437, + 225, + 449 + ], + "score": 1.0, + "content": "for all timesteps. Then main", + "type": "text" + }, + { + "bbox": [ + 225, + 437, + 239, + 447 + ], + "score": 0.29, + "content": "\\mathrm { ( m ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 437, + 505, + 449 + ], + "score": 1.0, + "content": "and extra (e) heads accuracy for the first steps are presented in B", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 448, + 506, + 460 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 506, + 460 + ], + "score": 1.0, + "content": "and C, respectively. Accuracy of the head predicting randomly assigned demonstration class is shown", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 458, + 507, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 507, + 471 + ], + "score": 1.0, + "content": "in D. Average discriminator predictions for training and holdout demonstration are shown in E and F.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 18 + } + ], + "index": 16.0 + }, + { + "type": "text", + "bbox": [ + 106, + 487, + 505, + 542 + ], + "lines": [ + { + "bbox": [ + 106, + 487, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 505, + 500 + ], + "score": 1.0, + "content": "In Fig. 5, we see the overall accuracy of the main head for TRAIL-0 is significantly higher, and", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 497, + 506, + 511 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 388, + 511 + ], + "score": 1.0, + "content": "the difference is larger for early steps (when TRAIL achieves only", + "type": "text" + }, + { + "bbox": [ + 388, + 498, + 408, + 509 + ], + "score": 0.86, + "content": "50 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 497, + 506, + 511 + ], + "score": 1.0, + "content": ", as expected). TRAIL", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 509, + 505, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 505, + 522 + ], + "score": 1.0, + "content": "representations are less helpful for extra heads (see Figure 5 C-D). Finally, TRAIL-0 clearly overfits", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 520, + 505, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 520, + 412, + 532 + ], + "score": 1.0, + "content": "on training demonstrations, predicting almost the maximum score, while only", + "type": "text" + }, + { + "bbox": [ + 413, + 520, + 442, + 531 + ], + "score": 0.85, + "content": "\\sim 0 . 2 5", + "type": "inline_equation" + }, + { + "bbox": [ + 443, + 520, + 505, + 532 + ], + "score": 1.0, + "content": "is predicted for", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 531, + 486, + 543 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 486, + 543 + ], + "score": 1.0, + "content": "holdout demonstrations. The TRAIL average predictions for both datasets are almost identical.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 108, + 561, + 264, + 572 + ], + "lines": [ + { + "bbox": [ + 106, + 561, + 265, + 574 + ], + "spans": [ + { + "bbox": [ + 106, + 561, + 265, + 574 + ], + "score": 1.0, + "content": "ACTOR EARLY STOPPING (TRAIL-0)", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 582, + 505, + 649 + ], + "lines": [ + { + "bbox": [ + 105, + 582, + 506, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 506, + 595 + ], + "score": 1.0, + "content": "In this section, we analyze the importance of adaptive early stopping on 3 tasks in the Jaco work-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 593, + 506, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 188, + 606 + ], + "score": 1.0, + "content": "space: lift red cube", + "type": "text" + }, + { + "bbox": [ + 189, + 595, + 207, + 605 + ], + "score": 0.32, + "content": "( l i f t )", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 593, + 294, + 606 + ], + "score": 1.0, + "content": ", put red cube in box", + "type": "text" + }, + { + "bbox": [ + 294, + 595, + 316, + 605 + ], + "score": 0.63, + "content": "( b o x )", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 593, + 506, + 606 + ], + "score": 1.0, + "content": ", and stack red cube on blue cube (stack). We", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 104, + 603, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 104, + 603, + 506, + 619 + ], + "score": 1.0, + "content": "consider D4PGfD and three GAIL-based models with varying termination policies: a) fixed step", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 616, + 506, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 506, + 629 + ], + "score": 1.0, + "content": "(50), b) based on ground truth task rewards, and c) based on adaptive early stopping (TRAIL-0).", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 627, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 506, + 640 + ], + "score": 1.0, + "content": "Using ground truth task rewards, an episode is terminated if the reward at the current step exceeds the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 639, + 488, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 488, + 650 + ], + "score": 1.0, + "content": "median reward of the episode so far for 10 consecutive steps. Results are presented in Figure 6.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 107, + 654, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "Termination based on task reward is clearly superior; although unrealistic in practice, it defines the", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "performance upper-bound and clearly shows that early stopping is beneficial. TRAIL-0 is robust", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 676, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 690 + ], + "score": 1.0, + "content": "and reaches human performance on all tasks. A fixed termination policy, when tuned, can be very", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "effective. The same fixed termination step, however, does not work for all tasks. See Figure 13 in", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "supplementary material for the effects of varying termination steps. Finally, as can be inferred from", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "stack results, the dense rewards provided by TRAIL-0 are helpful in solving this challenging problem", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 721, + 453, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 453, + 732 + ], + "score": 1.0, + "content": "which is unsolved with D4PGfD even though D4PGfD uses ground truth task rewards.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 149 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "ResNet for the lift distracted task. The first head is trained on the first frames only, and has the same", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "target as the main head (i.e. discriminating between agent and expert). To train the second head, we", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "randomly divide the expert demonstrations into two equi-numerous subsets, and the task is to predict", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 115, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 505, + 127 + ], + "score": 1.0, + "content": "to which of these randomly chosen sets the demonstration was assigned to. Both heads are trained", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 127, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 127, + 505, + 140 + ], + "score": 1.0, + "content": "via backpropagation but their gradient is not propagated to the ResNet so they do not influence the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 217, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 217, + 150 + ], + "score": 1.0, + "content": "training procedure directly.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5, + "bbox_fs": [ + 105, + 82, + 505, + 150 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 154, + 505, + 209 + ], + "lines": [ + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "score": 1.0, + "content": "If our claim is correct, we expect the extra heads to have higher accuracy for TRAIL-0 as compared", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "score": 1.0, + "content": "to TRAIL, since TRAIL representations are penalized for having features triggering memorization,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 175, + 506, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 175, + 506, + 189 + ], + "score": 1.0, + "content": "i.e. the features should not aid discriminating based on the first frames or predicting a random label", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 506, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 432, + 200 + ], + "score": 1.0, + "content": "for each expert demonstration. No reasonably performing method is able to force", + "type": "text" + }, + { + "bbox": [ + 433, + 187, + 452, + 198 + ], + "score": 0.87, + "content": "50 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 187, + 506, + 200 + ], + "score": 1.0, + "content": "accuracy for", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 494, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 494, + 211 + ], + "score": 1.0, + "content": "extra heads since some features are important to solve the task (e.g. the position of the red cube).", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 153, + 506, + 211 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 215, + 504, + 238 + ], + "lines": [ + { + "bbox": [ + 106, + 214, + 505, + 228 + ], + "spans": [ + { + "bbox": [ + 106, + 214, + 505, + 228 + ], + "score": 1.0, + "content": "We also collected 25 extra holdout demonstrations and visualize the average discriminator prediction", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 227, + 390, + 238 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 390, + 238 + ], + "score": 1.0, + "content": "on them, and compare with predictions on the training demonstrations.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5, + "bbox_fs": [ + 106, + 214, + 505, + 238 + ] + }, + { + "type": "image", + "bbox": [ + 114, + 251, + 488, + 407 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 114, + 251, + 488, + 407 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 114, + 251, + 488, + 407 + ], + "spans": [ + { + "bbox": [ + 114, + 251, + 488, + 407 + ], + "score": 0.969, + "type": "image", + "image_path": "f3d0ef0720ecd274b57537e078d92668d28a832dccb1c8bad24328a24d337bc8.jpg" + } + ] + } + ], + "index": 14, + "virtual_lines": [ + { + "bbox": [ + 114, + 251, + 488, + 303.0 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 114, + 303.0, + 488, + 355.0 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 114, + 355.0, + 488, + 407.0 + ], + "spans": [], + "index": 15 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 414, + 505, + 470 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 413, + 506, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 506, + 428 + ], + "score": 1.0, + "content": "Figure 5: Demonstrating the memorization problem on the lift distracted task (here higher accuracy", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 424, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 505, + 439 + ], + "score": 1.0, + "content": "is worse). Accuracy of different discriminator heads is presented (A-D). In A, the overall accuracy", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 437, + 505, + 449 + ], + "spans": [ + { + "bbox": [ + 106, + 437, + 225, + 449 + ], + "score": 1.0, + "content": "for all timesteps. Then main", + "type": "text" + }, + { + "bbox": [ + 225, + 437, + 239, + 447 + ], + "score": 0.29, + "content": "\\mathrm { ( m ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 437, + 505, + 449 + ], + "score": 1.0, + "content": "and extra (e) heads accuracy for the first steps are presented in B", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 448, + 506, + 460 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 506, + 460 + ], + "score": 1.0, + "content": "and C, respectively. Accuracy of the head predicting randomly assigned demonstration class is shown", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 458, + 507, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 507, + 471 + ], + "score": 1.0, + "content": "in D. Average discriminator predictions for training and holdout demonstration are shown in E and F.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 18 + } + ], + "index": 16.0 + }, + { + "type": "text", + "bbox": [ + 106, + 487, + 505, + 542 + ], + "lines": [ + { + "bbox": [ + 106, + 487, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 505, + 500 + ], + "score": 1.0, + "content": "In Fig. 5, we see the overall accuracy of the main head for TRAIL-0 is significantly higher, and", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 497, + 506, + 511 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 388, + 511 + ], + "score": 1.0, + "content": "the difference is larger for early steps (when TRAIL achieves only", + "type": "text" + }, + { + "bbox": [ + 388, + 498, + 408, + 509 + ], + "score": 0.86, + "content": "50 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 497, + 506, + 511 + ], + "score": 1.0, + "content": ", as expected). TRAIL", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 509, + 505, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 505, + 522 + ], + "score": 1.0, + "content": "representations are less helpful for extra heads (see Figure 5 C-D). Finally, TRAIL-0 clearly overfits", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 520, + 505, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 520, + 412, + 532 + ], + "score": 1.0, + "content": "on training demonstrations, predicting almost the maximum score, while only", + "type": "text" + }, + { + "bbox": [ + 413, + 520, + 442, + 531 + ], + "score": 0.85, + "content": "\\sim 0 . 2 5", + "type": "inline_equation" + }, + { + "bbox": [ + 443, + 520, + 505, + 532 + ], + "score": 1.0, + "content": "is predicted for", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 531, + 486, + 543 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 486, + 543 + ], + "score": 1.0, + "content": "holdout demonstrations. The TRAIL average predictions for both datasets are almost identical.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 487, + 506, + 543 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 561, + 264, + 572 + ], + "lines": [ + { + "bbox": [ + 106, + 561, + 265, + 574 + ], + "spans": [ + { + "bbox": [ + 106, + 561, + 265, + 574 + ], + "score": 1.0, + "content": "ACTOR EARLY STOPPING (TRAIL-0)", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26, + "bbox_fs": [ + 106, + 561, + 265, + 574 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 582, + 505, + 649 + ], + "lines": [ + { + "bbox": [ + 105, + 582, + 506, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 506, + 595 + ], + "score": 1.0, + "content": "In this section, we analyze the importance of adaptive early stopping on 3 tasks in the Jaco work-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 593, + 506, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 188, + 606 + ], + "score": 1.0, + "content": "space: lift red cube", + "type": "text" + }, + { + "bbox": [ + 189, + 595, + 207, + 605 + ], + "score": 0.32, + "content": "( l i f t )", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 593, + 294, + 606 + ], + "score": 1.0, + "content": ", put red cube in box", + "type": "text" + }, + { + "bbox": [ + 294, + 595, + 316, + 605 + ], + "score": 0.63, + "content": "( b o x )", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 593, + 506, + 606 + ], + "score": 1.0, + "content": ", and stack red cube on blue cube (stack). We", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 104, + 603, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 104, + 603, + 506, + 619 + ], + "score": 1.0, + "content": "consider D4PGfD and three GAIL-based models with varying termination policies: a) fixed step", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 616, + 506, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 506, + 629 + ], + "score": 1.0, + "content": "(50), b) based on ground truth task rewards, and c) based on adaptive early stopping (TRAIL-0).", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 627, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 506, + 640 + ], + "score": 1.0, + "content": "Using ground truth task rewards, an episode is terminated if the reward at the current step exceeds the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 639, + 488, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 488, + 650 + ], + "score": 1.0, + "content": "median reward of the episode so far for 10 consecutive steps. Results are presented in Figure 6.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 29.5, + "bbox_fs": [ + 104, + 582, + 506, + 650 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 654, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "Termination based on task reward is clearly superior; although unrealistic in practice, it defines the", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "performance upper-bound and clearly shows that early stopping is beneficial. TRAIL-0 is robust", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 676, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 690 + ], + "score": 1.0, + "content": "and reaches human performance on all tasks. A fixed termination policy, when tuned, can be very", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "effective. The same fixed termination step, however, does not work for all tasks. See Figure 13 in", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "supplementary material for the effects of varying termination steps. Finally, as can be inferred from", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "stack results, the dense rewards provided by TRAIL-0 are helpful in solving this challenging problem", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 721, + 453, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 453, + 732 + ], + "score": 1.0, + "content": "which is unsolved with D4PGfD even though D4PGfD uses ground truth task rewards.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36, + "bbox_fs": [ + 105, + 655, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 111, + 75, + 493, + 168 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 111, + 75, + 493, + 168 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 111, + 75, + 493, + 168 + ], + "spans": [ + { + "bbox": [ + 111, + 75, + 493, + 168 + ], + "score": 0.967, + "type": "image", + "image_path": "236f966ae10dec709f176a7097a72d5e3722052c12c4e9e616a6e0ea34d38c6a.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 111, + 75, + 493, + 106.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 111, + 106.0, + 493, + 137.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 111, + 137.0, + 493, + 168.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 181, + 174, + 429, + 186 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 181, + 173, + 430, + 187 + ], + "spans": [ + { + "bbox": [ + 181, + 173, + 430, + 187 + ], + "score": 1.0, + "content": "Figure 6: Results for lift, box, and stack on Jaco environment.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "title", + "bbox": [ + 108, + 211, + 202, + 222 + ], + "lines": [ + { + "bbox": [ + 106, + 212, + 203, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 203, + 222 + ], + "score": 1.0, + "content": "DATA AUGMENTATION", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 107, + 232, + 506, + 266 + ], + "lines": [ + { + "bbox": [ + 105, + 231, + 506, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 506, + 245 + ], + "score": 1.0, + "content": "In Table 5.2, we report the best reward obtained in the first 12 hours of training (averaged for all seeds;", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 243, + 507, + 255 + ], + "spans": [ + { + "bbox": [ + 106, + 243, + 507, + 255 + ], + "score": 1.0, + "content": "see Figure 14 for full curves). The results show that data augmentation is needed in lift distracted.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 254, + 453, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 453, + 267 + ], + "score": 1.0, + "content": "For the lift alone task, TRAIL-0 with data augmentation performs on par with TRAIL.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "table", + "bbox": [ + 155, + 281, + 454, + 349 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 155, + 281, + 454, + 349 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 155, + 281, + 454, + 349 + ], + "spans": [ + { + "bbox": [ + 155, + 281, + 454, + 349 + ], + "score": 0.98, + "html": "
TaskRegularizationData augmentationNo data augmentation
lift aloneTRAIL-0 TRAIL~165~115
lift distractedTRAIL-0~155~165
TRAIL~30 ~180~5 ~10
", + "type": "table", + "image_path": "44e435f0cddc322fb45ee6a3331dd739fc71ea12dd406b3c24ab878b32347dd0.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 155, + 281, + 454, + 303.6666666666667 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 155, + 303.6666666666667, + 454, + 326.33333333333337 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 155, + 326.33333333333337, + 454, + 349.00000000000006 + ], + "spans": [], + "index": 10 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 111, + 353, + 494, + 365 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 113, + 351, + 496, + 366 + ], + "spans": [ + { + "bbox": [ + 113, + 351, + 496, + 366 + ], + "score": 1.0, + "content": "Table 1: Influence of data augmentation (evaluated on rewards) for lift alone and lift distracted.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + } + ], + "index": 10.0 + }, + { + "type": "text", + "bbox": [ + 106, + 381, + 505, + 403 + ], + "lines": [ + { + "bbox": [ + 105, + 380, + 506, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 506, + 394 + ], + "score": 1.0, + "content": "The performance of TRAIL is not affected by the lack of data augmentation on the lift alone task,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 392, + 270, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 270, + 404 + ], + "score": 1.0, + "content": "whereas the performance of TRAIL-0 is.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5 + }, + { + "type": "title", + "bbox": [ + 106, + 422, + 330, + 433 + ], + "lines": [ + { + "bbox": [ + 106, + 423, + 330, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 423, + 330, + 433 + ], + "score": 1.0, + "content": "LEARNING WITH A FIXED, PERFECT DISCRIMINATOR", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 442, + 505, + 510 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 506, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 506, + 456 + ], + "score": 1.0, + "content": "To assess whether learned discriminators are necessary, we compare TRAIL against agents using", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 453, + 506, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 278, + 468 + ], + "score": 1.0, + "content": "a fixed reward function corresponding to", + "type": "text" + }, + { + "bbox": [ + 278, + 454, + 331, + 466 + ], + "score": 0.91, + "content": "R _ { e x p e r t } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 453, + 351, + 468 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 351, + 454, + 401, + 466 + ], + "score": 0.91, + "content": "R _ { a g e n t } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 453, + 506, + 468 + ], + "score": 1.0, + "content": "for the lift alone and lift", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 465, + 506, + 477 + ], + "spans": [ + { + "bbox": [ + 106, + 465, + 506, + 477 + ], + "score": 1.0, + "content": "distracted tasks. This baseline simulates an oracle discriminator with perfect generalization, but", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 475, + 505, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 505, + 489 + ], + "score": 1.0, + "content": "which is agnostic to behavior. On the lift alone task, agents using this fixed reward achieve roughly", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 486, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 505, + 500 + ], + "score": 1.0, + "content": "half the reward of TRAIL asymptotically, and on lift distracted they do not solve the task (average", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 498, + 405, + 510 + ], + "spans": [ + { + "bbox": [ + 106, + 498, + 405, + 510 + ], + "score": 1.0, + "content": "rewards are less than 5). See supplementary Figure 16 for learning curves.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17.5 + }, + { + "type": "title", + "bbox": [ + 106, + 529, + 350, + 539 + ], + "lines": [ + { + "bbox": [ + 106, + 528, + 352, + 541 + ], + "spans": [ + { + "bbox": [ + 106, + 528, + 352, + 541 + ], + "score": 1.0, + "content": "5.3 LEARNING FROM OTHER EMBODIMENTS AND PROPS", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 551, + 506, + 595 + ], + "lines": [ + { + "bbox": [ + 105, + 551, + 506, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 506, + 563 + ], + "score": 1.0, + "content": "Since the TRAIL discriminator is trained to ignore task-irrelevant features, it can learn from demon-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 563, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 106, + 563, + 505, + 574 + ], + "score": 1.0, + "content": "strations with different embodiments and props. Figure 7 shows that GAIL even with augmentation", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 573, + 506, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 506, + 586 + ], + "score": 1.0, + "content": "fails to learn block lifting from a different embodiment, and performs worse when the expert uses a", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 584, + 469, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 469, + 596 + ], + "score": 1.0, + "content": "different prop color. TRAIL solves the task and achieves better performance in both cases.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5 + }, + { + "type": "image", + "bbox": [ + 125, + 611, + 485, + 703 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 125, + 611, + 485, + 703 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 125, + 611, + 485, + 703 + ], + "spans": [ + { + "bbox": [ + 125, + 611, + 485, + 703 + ], + "score": 0.971, + "type": "image", + "image_path": "c312fba1da06c95e98c0f3e62ac762e79d2ef8e05c275905eb6accf57d14aeb2.jpg" + } + ] + } + ], + "index": 27, + "virtual_lines": [ + { + "bbox": [ + 125, + 611, + 485, + 641.6666666666666 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 125, + 641.6666666666666, + 485, + 672.3333333333333 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 125, + 672.3333333333333, + 485, + 702.9999999999999 + ], + "spans": [], + "index": 28 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 120, + 707, + 487, + 720 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 122, + 707, + 488, + 721 + ], + "spans": [ + { + "bbox": [ + 122, + 707, + 488, + 721 + ], + "score": 1.0, + "content": "Figure 7: When the expert differs in body or prop appearance, TRAIL outperforms GAIL.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + } + ], + "index": 28.0 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 300, + 750, + 309, + 761 + ], + "spans": [ + { + "bbox": [ + 300, + 750, + 309, + 761 + ], + "score": 1.0, + "content": "8", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 111, + 75, + 493, + 168 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 111, + 75, + 493, + 168 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 111, + 75, + 493, + 168 + ], + "spans": [ + { + "bbox": [ + 111, + 75, + 493, + 168 + ], + "score": 0.967, + "type": "image", + "image_path": "236f966ae10dec709f176a7097a72d5e3722052c12c4e9e616a6e0ea34d38c6a.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 111, + 75, + 493, + 106.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 111, + 106.0, + 493, + 137.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 111, + 137.0, + 493, + 168.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 181, + 174, + 429, + 186 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 181, + 173, + 430, + 187 + ], + "spans": [ + { + "bbox": [ + 181, + 173, + 430, + 187 + ], + "score": 1.0, + "content": "Figure 6: Results for lift, box, and stack on Jaco environment.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "title", + "bbox": [ + 108, + 211, + 202, + 222 + ], + "lines": [ + { + "bbox": [ + 106, + 212, + 203, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 203, + 222 + ], + "score": 1.0, + "content": "DATA AUGMENTATION", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "list", + "bbox": [ + 107, + 232, + 506, + 266 + ], + "lines": [ + { + "bbox": [ + 105, + 231, + 506, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 506, + 245 + ], + "score": 1.0, + "content": "In Table 5.2, we report the best reward obtained in the first 12 hours of training (averaged for all seeds;", + "type": "text" + } + ], + "index": 5, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 243, + 507, + 255 + ], + "spans": [ + { + "bbox": [ + 106, + 243, + 507, + 255 + ], + "score": 1.0, + "content": "see Figure 14 for full curves). The results show that data augmentation is needed in lift distracted.", + "type": "text" + } + ], + "index": 6, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 254, + 453, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 453, + 267 + ], + "score": 1.0, + "content": "For the lift alone task, TRAIL-0 with data augmentation performs on par with TRAIL.", + "type": "text" + } + ], + "index": 7, + "is_list_start_line": true, + "is_list_end_line": true + } + ], + "index": 6, + "bbox_fs": [ + 105, + 231, + 507, + 267 + ] + }, + { + "type": "table", + "bbox": [ + 155, + 281, + 454, + 349 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 155, + 281, + 454, + 349 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 155, + 281, + 454, + 349 + ], + "spans": [ + { + "bbox": [ + 155, + 281, + 454, + 349 + ], + "score": 0.98, + "html": "
TaskRegularizationData augmentationNo data augmentation
lift aloneTRAIL-0 TRAIL~165~115
lift distractedTRAIL-0~155~165
TRAIL~30 ~180~5 ~10
", + "type": "table", + "image_path": "44e435f0cddc322fb45ee6a3331dd739fc71ea12dd406b3c24ab878b32347dd0.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 155, + 281, + 454, + 303.6666666666667 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 155, + 303.6666666666667, + 454, + 326.33333333333337 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 155, + 326.33333333333337, + 454, + 349.00000000000006 + ], + "spans": [], + "index": 10 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 111, + 353, + 494, + 365 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 113, + 351, + 496, + 366 + ], + "spans": [ + { + "bbox": [ + 113, + 351, + 496, + 366 + ], + "score": 1.0, + "content": "Table 1: Influence of data augmentation (evaluated on rewards) for lift alone and lift distracted.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + } + ], + "index": 10.0 + }, + { + "type": "text", + "bbox": [ + 106, + 381, + 505, + 403 + ], + "lines": [ + { + "bbox": [ + 105, + 380, + 506, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 506, + 394 + ], + "score": 1.0, + "content": "The performance of TRAIL is not affected by the lack of data augmentation on the lift alone task,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 392, + 270, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 270, + 404 + ], + "score": 1.0, + "content": "whereas the performance of TRAIL-0 is.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5, + "bbox_fs": [ + 105, + 380, + 506, + 404 + ] + }, + { + "type": "title", + "bbox": [ + 106, + 422, + 330, + 433 + ], + "lines": [ + { + "bbox": [ + 106, + 423, + 330, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 423, + 330, + 433 + ], + "score": 1.0, + "content": "LEARNING WITH A FIXED, PERFECT DISCRIMINATOR", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 442, + 505, + 510 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 506, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 506, + 456 + ], + "score": 1.0, + "content": "To assess whether learned discriminators are necessary, we compare TRAIL against agents using", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 453, + 506, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 278, + 468 + ], + "score": 1.0, + "content": "a fixed reward function corresponding to", + "type": "text" + }, + { + "bbox": [ + 278, + 454, + 331, + 466 + ], + "score": 0.91, + "content": "R _ { e x p e r t } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 453, + 351, + 468 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 351, + 454, + 401, + 466 + ], + "score": 0.91, + "content": "R _ { a g e n t } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 453, + 506, + 468 + ], + "score": 1.0, + "content": "for the lift alone and lift", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 465, + 506, + 477 + ], + "spans": [ + { + "bbox": [ + 106, + 465, + 506, + 477 + ], + "score": 1.0, + "content": "distracted tasks. This baseline simulates an oracle discriminator with perfect generalization, but", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 475, + 505, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 505, + 489 + ], + "score": 1.0, + "content": "which is agnostic to behavior. On the lift alone task, agents using this fixed reward achieve roughly", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 486, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 505, + 500 + ], + "score": 1.0, + "content": "half the reward of TRAIL asymptotically, and on lift distracted they do not solve the task (average", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 498, + 405, + 510 + ], + "spans": [ + { + "bbox": [ + 106, + 498, + 405, + 510 + ], + "score": 1.0, + "content": "rewards are less than 5). See supplementary Figure 16 for learning curves.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17.5, + "bbox_fs": [ + 105, + 442, + 506, + 510 + ] + }, + { + "type": "title", + "bbox": [ + 106, + 529, + 350, + 539 + ], + "lines": [ + { + "bbox": [ + 106, + 528, + 352, + 541 + ], + "spans": [ + { + "bbox": [ + 106, + 528, + 352, + 541 + ], + "score": 1.0, + "content": "5.3 LEARNING FROM OTHER EMBODIMENTS AND PROPS", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 551, + 506, + 595 + ], + "lines": [ + { + "bbox": [ + 105, + 551, + 506, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 506, + 563 + ], + "score": 1.0, + "content": "Since the TRAIL discriminator is trained to ignore task-irrelevant features, it can learn from demon-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 563, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 106, + 563, + 505, + 574 + ], + "score": 1.0, + "content": "strations with different embodiments and props. Figure 7 shows that GAIL even with augmentation", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 573, + 506, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 506, + 586 + ], + "score": 1.0, + "content": "fails to learn block lifting from a different embodiment, and performs worse when the expert uses a", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 584, + 469, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 469, + 596 + ], + "score": 1.0, + "content": "different prop color. TRAIL solves the task and achieves better performance in both cases.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 551, + 506, + 596 + ] + }, + { + "type": "image", + "bbox": [ + 125, + 611, + 485, + 703 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 125, + 611, + 485, + 703 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 125, + 611, + 485, + 703 + ], + "spans": [ + { + "bbox": [ + 125, + 611, + 485, + 703 + ], + "score": 0.971, + "type": "image", + "image_path": "c312fba1da06c95e98c0f3e62ac762e79d2ef8e05c275905eb6accf57d14aeb2.jpg" + } + ] + } + ], + "index": 27, + "virtual_lines": [ + { + "bbox": [ + 125, + 611, + 485, + 641.6666666666666 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 125, + 641.6666666666666, + 485, + 672.3333333333333 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 125, + 672.3333333333333, + 485, + 702.9999999999999 + ], + "spans": [], + "index": 28 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 120, + 707, + 487, + 720 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 122, + 707, + 488, + 721 + ], + "spans": [ + { + "bbox": [ + 122, + 707, + 488, + 721 + ], + "score": 1.0, + "content": "Figure 7: When the expert differs in body or prop appearance, TRAIL outperforms GAIL.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + } + ], + "index": 28.0 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 83, + 338, + 93 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 341, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 341, + 95 + ], + "score": 1.0, + "content": "5.4 EVALUATION ON DIVERSE MANIPULATION TASKS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 106, + 103, + 506, + 169 + ], + "lines": [ + { + "bbox": [ + 105, + 102, + 507, + 115 + ], + "spans": [ + { + "bbox": [ + 105, + 102, + 507, + 115 + ], + "score": 1.0, + "content": "To further demonstrate benefits of using our proposed method, we present results for TRAIL, TRAIL-", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 113, + 506, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 113, + 506, + 127 + ], + "score": 1.0, + "content": "0, the baseline GAIL, and BC on more challenging tasks. Specifically, we consider stack with the", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 124, + 506, + 137 + ], + "spans": [ + { + "bbox": [ + 105, + 124, + 506, + 137 + ], + "score": 1.0, + "content": "Sawyer robot; and insertion and stack banana in the Jaco work-space. The results are shown in", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 137, + 506, + 148 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 506, + 148 + ], + "score": 1.0, + "content": "Figure 8. The tasks we consider here are much harder as evidenced by the performance of BC agents.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 146, + 506, + 159 + ], + "spans": [ + { + "bbox": [ + 105, + 146, + 506, + 159 + ], + "score": 1.0, + "content": "These experiments suggest that TRAIL is generally useful as an improvement over GAIL, even when", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 159, + 365, + 170 + ], + "spans": [ + { + "bbox": [ + 106, + 159, + 365, + 170 + ], + "score": 1.0, + "content": "the tasks are not designed to include task-irrelevant information.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3.5 + }, + { + "type": "image", + "bbox": [ + 114, + 180, + 491, + 272 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 114, + 180, + 491, + 272 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 114, + 180, + 491, + 272 + ], + "spans": [ + { + "bbox": [ + 114, + 180, + 491, + 272 + ], + "score": 0.967, + "type": "image", + "image_path": "b34a66b68ab4b752173566a72eef0ab16bcf79a532090242dd93629c664709c9.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 114, + 180, + 491, + 210.66666666666666 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 114, + 210.66666666666666, + 491, + 241.33333333333331 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 114, + 241.33333333333331, + 491, + 272.0 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 123, + 277, + 484, + 289 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 125, + 276, + 485, + 291 + ], + "spans": [ + { + "bbox": [ + 125, + 276, + 485, + 291 + ], + "score": 1.0, + "content": "Figure 8: Results comparing TRAIL, TRAIL-0 and GAIL for diverse manipulation tasks.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + } + ], + "index": 9.0 + }, + { + "type": "title", + "bbox": [ + 107, + 312, + 201, + 324 + ], + "lines": [ + { + "bbox": [ + 105, + 309, + 204, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 204, + 327 + ], + "score": 1.0, + "content": "6 CONCLUSIONS", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 337, + 506, + 392 + ], + "lines": [ + { + "bbox": [ + 106, + 336, + 506, + 349 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 506, + 349 + ], + "score": 1.0, + "content": "To make adversarial imitation work on nontrivial tasks from pixels, it is crucial to prevent the dis-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 347, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 506, + 361 + ], + "score": 1.0, + "content": "criminator from exploiting task-irrelevant information. Data augmentation is a necessary component", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 358, + 507, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 507, + 374 + ], + "score": 1.0, + "content": "that prevents the discriminator from overfitting, but alone is not sufficient to solve more challeng-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 370, + 506, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 506, + 383 + ], + "score": 1.0, + "content": "ing problems. Our proposed method TRAIL proved to be a remedy which effectively focuses the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 380, + 394, + 393 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 394, + 393 + ], + "score": 1.0, + "content": "discriminator on the task even when task-irrelevant features are present.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 108, + 397, + 504, + 431 + ], + "lines": [ + { + "bbox": [ + 105, + 396, + 506, + 412 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 506, + 412 + ], + "score": 1.0, + "content": "We showed through ablations that TRAIL benefits from data augmentation, actor early stopping,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 409, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 409, + 505, + 420 + ], + "score": 1.0, + "content": "and the use of invariant set constraints. The last enables our agent to solve the full task suite in our", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 420, + 290, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 290, + 433 + ], + "score": 1.0, + "content": "experiments showing its decisive importance.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "title", + "bbox": [ + 108, + 453, + 175, + 465 + ], + "lines": [ + { + "bbox": [ + 106, + 453, + 176, + 467 + ], + "spans": [ + { + "bbox": [ + 106, + 453, + 176, + 467 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 471, + 505, + 492 + ], + "lines": [ + { + "bbox": [ + 105, + 470, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 506, + 484 + ], + "score": 1.0, + "content": "Pieter Abbeel and Andrew Y Ng. Apprenticeship learning via inverse reinforcement learning. In Proceedings of", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 117, + 482, + 414, + 493 + ], + "spans": [ + { + "bbox": [ + 117, + 482, + 414, + 493 + ], + "score": 1.0, + "content": "the twenty-first international conference on Machine learning, pp. 1. ACM, 2004.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5 + }, + { + "type": "text", + "bbox": [ + 106, + 500, + 504, + 521 + ], + "lines": [ + { + "bbox": [ + 105, + 499, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 105, + 499, + 505, + 512 + ], + "score": 1.0, + "content": "Paul Bakker and Yasuo Kuniyoshi. Robot see, robot do: An overview of robot imitation. In AISB96 Workshop", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 510, + 271, + 521 + ], + "spans": [ + { + "bbox": [ + 115, + 510, + 271, + 521 + ], + "score": 1.0, + "content": "on Learning in Robots and Animals, 1996.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 106, + 528, + 504, + 550 + ], + "lines": [ + { + "bbox": [ + 104, + 526, + 506, + 542 + ], + "spans": [ + { + "bbox": [ + 104, + 526, + 506, + 542 + ], + "score": 1.0, + "content": "Nir Baram, Oron Anschel, Itai Caspi, and Shie Mannor. End-to-end differentiable adversarial imitation learning.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 538, + 175, + 550 + ], + "spans": [ + { + "bbox": [ + 115, + 538, + 175, + 550 + ], + "score": 1.0, + "content": "In ICML, 2017.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 106, + 557, + 504, + 588 + ], + "lines": [ + { + "bbox": [ + 106, + 558, + 504, + 568 + ], + "spans": [ + { + "bbox": [ + 106, + 558, + 504, + 568 + ], + "score": 1.0, + "content": "Gabriel Barth-Maron, Matthew W Hoffman, David Budden, Will Dabney, Dan Horgan, Alistair Muldal, Nicolas", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 568, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 116, + 568, + 505, + 578 + ], + "score": 1.0, + "content": "Heess, and Timothy Lillicrap. Distributed distributional deterministic policy gradients. arXiv preprint", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 578, + 208, + 588 + ], + "spans": [ + { + "bbox": [ + 115, + 578, + 208, + 588 + ], + "score": 1.0, + "content": "arXiv:1804.08617, 2018.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 105, + 596, + 505, + 617 + ], + "lines": [ + { + "bbox": [ + 105, + 594, + 507, + 610 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 507, + 610 + ], + "score": 1.0, + "content": "Marc G Bellemare, Will Dabney, and Rémi Munos. A distributional perspective on reinforcement learning.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 116, + 606, + 263, + 617 + ], + "spans": [ + { + "bbox": [ + 116, + 606, + 263, + 617 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1707.06887, 2017.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5 + }, + { + "type": "text", + "bbox": [ + 106, + 624, + 504, + 646 + ], + "lines": [ + { + "bbox": [ + 106, + 624, + 505, + 637 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 505, + 637 + ], + "score": 1.0, + "content": "Glen Berseth and Christopher J Pal. Visual imitation learning with recurrent siamese networks. arXiv preprint", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 635, + 209, + 645 + ], + "spans": [ + { + "bbox": [ + 115, + 635, + 209, + 645 + ], + "score": 1.0, + "content": "arXiv:1901.07186, 2019.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 106, + 653, + 504, + 675 + ], + "lines": [ + { + "bbox": [ + 105, + 652, + 506, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 506, + 666 + ], + "score": 1.0, + "content": "Lionel Blondé and Alexandros Kalousis. Sample-efficient imitation learning via generative adversarial nets.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 664, + 262, + 675 + ], + "spans": [ + { + "bbox": [ + 115, + 664, + 262, + 675 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1809.02064, 2018.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5 + }, + { + "type": "text", + "bbox": [ + 106, + 682, + 504, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 681, + 505, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 505, + 695 + ], + "score": 1.0, + "content": "Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale GAN training for high fidelity natural image", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 693, + 389, + 704 + ], + "spans": [ + { + "bbox": [ + 115, + 693, + 389, + 704 + ], + "score": 1.0, + "content": "synthesis. In International Conference on Learning Representations, 2019.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 106, + 711, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 505, + 724 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 724 + ], + "score": 1.0, + "content": "Djork-Arné Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network learning by", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 721, + 375, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 375, + 732 + ], + "score": 1.0, + "content": "exponential linear units (elus). arXiv preprint arXiv:1511.07289, 2015.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 83, + 338, + 93 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 341, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 341, + 95 + ], + "score": 1.0, + "content": "5.4 EVALUATION ON DIVERSE MANIPULATION TASKS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 106, + 103, + 506, + 169 + ], + "lines": [ + { + "bbox": [ + 105, + 102, + 507, + 115 + ], + "spans": [ + { + "bbox": [ + 105, + 102, + 507, + 115 + ], + "score": 1.0, + "content": "To further demonstrate benefits of using our proposed method, we present results for TRAIL, TRAIL-", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 113, + 506, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 113, + 506, + 127 + ], + "score": 1.0, + "content": "0, the baseline GAIL, and BC on more challenging tasks. Specifically, we consider stack with the", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 124, + 506, + 137 + ], + "spans": [ + { + "bbox": [ + 105, + 124, + 506, + 137 + ], + "score": 1.0, + "content": "Sawyer robot; and insertion and stack banana in the Jaco work-space. The results are shown in", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 137, + 506, + 148 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 506, + 148 + ], + "score": 1.0, + "content": "Figure 8. The tasks we consider here are much harder as evidenced by the performance of BC agents.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 146, + 506, + 159 + ], + "spans": [ + { + "bbox": [ + 105, + 146, + 506, + 159 + ], + "score": 1.0, + "content": "These experiments suggest that TRAIL is generally useful as an improvement over GAIL, even when", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 159, + 365, + 170 + ], + "spans": [ + { + "bbox": [ + 106, + 159, + 365, + 170 + ], + "score": 1.0, + "content": "the tasks are not designed to include task-irrelevant information.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 102, + 507, + 170 + ] + }, + { + "type": "image", + "bbox": [ + 114, + 180, + 491, + 272 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 114, + 180, + 491, + 272 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 114, + 180, + 491, + 272 + ], + "spans": [ + { + "bbox": [ + 114, + 180, + 491, + 272 + ], + "score": 0.967, + "type": "image", + "image_path": "b34a66b68ab4b752173566a72eef0ab16bcf79a532090242dd93629c664709c9.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 114, + 180, + 491, + 210.66666666666666 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 114, + 210.66666666666666, + 491, + 241.33333333333331 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 114, + 241.33333333333331, + 491, + 272.0 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 123, + 277, + 484, + 289 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 125, + 276, + 485, + 291 + ], + "spans": [ + { + "bbox": [ + 125, + 276, + 485, + 291 + ], + "score": 1.0, + "content": "Figure 8: Results comparing TRAIL, TRAIL-0 and GAIL for diverse manipulation tasks.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + } + ], + "index": 9.0 + }, + { + "type": "title", + "bbox": [ + 107, + 312, + 201, + 324 + ], + "lines": [ + { + "bbox": [ + 105, + 309, + 204, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 204, + 327 + ], + "score": 1.0, + "content": "6 CONCLUSIONS", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 337, + 506, + 392 + ], + "lines": [ + { + "bbox": [ + 106, + 336, + 506, + 349 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 506, + 349 + ], + "score": 1.0, + "content": "To make adversarial imitation work on nontrivial tasks from pixels, it is crucial to prevent the dis-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 347, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 506, + 361 + ], + "score": 1.0, + "content": "criminator from exploiting task-irrelevant information. Data augmentation is a necessary component", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 358, + 507, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 507, + 374 + ], + "score": 1.0, + "content": "that prevents the discriminator from overfitting, but alone is not sufficient to solve more challeng-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 370, + 506, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 506, + 383 + ], + "score": 1.0, + "content": "ing problems. Our proposed method TRAIL proved to be a remedy which effectively focuses the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 380, + 394, + 393 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 394, + 393 + ], + "score": 1.0, + "content": "discriminator on the task even when task-irrelevant features are present.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 14, + "bbox_fs": [ + 105, + 336, + 507, + 393 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 397, + 504, + 431 + ], + "lines": [ + { + "bbox": [ + 105, + 396, + 506, + 412 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 506, + 412 + ], + "score": 1.0, + "content": "We showed through ablations that TRAIL benefits from data augmentation, actor early stopping,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 409, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 409, + 505, + 420 + ], + "score": 1.0, + "content": "and the use of invariant set constraints. The last enables our agent to solve the full task suite in our", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 420, + 290, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 290, + 433 + ], + "score": 1.0, + "content": "experiments showing its decisive importance.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 396, + 506, + 433 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 453, + 175, + 465 + ], + "lines": [ + { + "bbox": [ + 106, + 453, + 176, + 467 + ], + "spans": [ + { + "bbox": [ + 106, + 453, + 176, + 467 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 471, + 505, + 492 + ], + "lines": [ + { + "bbox": [ + 105, + 470, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 506, + 484 + ], + "score": 1.0, + "content": "Pieter Abbeel and Andrew Y Ng. Apprenticeship learning via inverse reinforcement learning. In Proceedings of", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 117, + 482, + 414, + 493 + ], + "spans": [ + { + "bbox": [ + 117, + 482, + 414, + 493 + ], + "score": 1.0, + "content": "the twenty-first international conference on Machine learning, pp. 1. ACM, 2004.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 470, + 506, + 493 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 500, + 504, + 521 + ], + "lines": [ + { + "bbox": [ + 105, + 499, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 105, + 499, + 505, + 512 + ], + "score": 1.0, + "content": "Paul Bakker and Yasuo Kuniyoshi. Robot see, robot do: An overview of robot imitation. In AISB96 Workshop", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 510, + 271, + 521 + ], + "spans": [ + { + "bbox": [ + 115, + 510, + 271, + 521 + ], + "score": 1.0, + "content": "on Learning in Robots and Animals, 1996.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 499, + 505, + 521 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 528, + 504, + 550 + ], + "lines": [ + { + "bbox": [ + 104, + 526, + 506, + 542 + ], + "spans": [ + { + "bbox": [ + 104, + 526, + 506, + 542 + ], + "score": 1.0, + "content": "Nir Baram, Oron Anschel, Itai Caspi, and Shie Mannor. End-to-end differentiable adversarial imitation learning.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 538, + 175, + 550 + ], + "spans": [ + { + "bbox": [ + 115, + 538, + 175, + 550 + ], + "score": 1.0, + "content": "In ICML, 2017.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5, + "bbox_fs": [ + 104, + 526, + 506, + 550 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 557, + 504, + 588 + ], + "lines": [ + { + "bbox": [ + 106, + 558, + 504, + 568 + ], + "spans": [ + { + "bbox": [ + 106, + 558, + 504, + 568 + ], + "score": 1.0, + "content": "Gabriel Barth-Maron, Matthew W Hoffman, David Budden, Will Dabney, Dan Horgan, Alistair Muldal, Nicolas", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 568, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 116, + 568, + 505, + 578 + ], + "score": 1.0, + "content": "Heess, and Timothy Lillicrap. Distributed distributional deterministic policy gradients. arXiv preprint", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 578, + 208, + 588 + ], + "spans": [ + { + "bbox": [ + 115, + 578, + 208, + 588 + ], + "score": 1.0, + "content": "arXiv:1804.08617, 2018.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28, + "bbox_fs": [ + 106, + 558, + 505, + 588 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 596, + 505, + 617 + ], + "lines": [ + { + "bbox": [ + 105, + 594, + 507, + 610 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 507, + 610 + ], + "score": 1.0, + "content": "Marc G Bellemare, Will Dabney, and Rémi Munos. A distributional perspective on reinforcement learning.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 116, + 606, + 263, + 617 + ], + "spans": [ + { + "bbox": [ + 116, + 606, + 263, + 617 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1707.06887, 2017.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 594, + 507, + 617 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 624, + 504, + 646 + ], + "lines": [ + { + "bbox": [ + 106, + 624, + 505, + 637 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 505, + 637 + ], + "score": 1.0, + "content": "Glen Berseth and Christopher J Pal. Visual imitation learning with recurrent siamese networks. arXiv preprint", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 635, + 209, + 645 + ], + "spans": [ + { + "bbox": [ + 115, + 635, + 209, + 645 + ], + "score": 1.0, + "content": "arXiv:1901.07186, 2019.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5, + "bbox_fs": [ + 106, + 624, + 505, + 645 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 653, + 504, + 675 + ], + "lines": [ + { + "bbox": [ + 105, + 652, + 506, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 506, + 666 + ], + "score": 1.0, + "content": "Lionel Blondé and Alexandros Kalousis. Sample-efficient imitation learning via generative adversarial nets.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 664, + 262, + 675 + ], + "spans": [ + { + "bbox": [ + 115, + 664, + 262, + 675 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1809.02064, 2018.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 652, + 506, + 675 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 682, + 504, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 681, + 505, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 505, + 695 + ], + "score": 1.0, + "content": "Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale GAN training for high fidelity natural image", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 693, + 389, + 704 + ], + "spans": [ + { + "bbox": [ + 115, + 693, + 389, + 704 + ], + "score": 1.0, + "content": "synthesis. In International Conference on Learning Representations, 2019.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 681, + 505, + 704 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 711, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 505, + 724 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 724 + ], + "score": 1.0, + "content": "Djork-Arné Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network learning by", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 721, + 375, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 375, + 732 + ], + "score": 1.0, + "content": "exponential linear units (elus). arXiv preprint arXiv:1511.07289, 2015.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5, + "bbox_fs": [ + 105, + 709, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 83, + 504, + 113 + ], + "lines": [ + { + "bbox": [ + 106, + 83, + 505, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 505, + 94 + ], + "score": 1.0, + "content": "Yan Duan, Marcin Andrychowicz, Bradly Stadie, OpenAI Jonathan Ho, Jonas Schneider, Ilya Sutskever, Pieter", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 92, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 115, + 92, + 505, + 105 + ], + "score": 1.0, + "content": "Abbeel, and Wojciech Zaremba. One-shot imitation learning. In Advances in neural information processing", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 104, + 230, + 114 + ], + "spans": [ + { + "bbox": [ + 115, + 104, + 230, + 114 + ], + "score": 1.0, + "content": "systems, pp. 1087–1098, 2017.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 108, + 120, + 504, + 142 + ], + "lines": [ + { + "bbox": [ + 107, + 121, + 505, + 132 + ], + "spans": [ + { + "bbox": [ + 107, + 121, + 505, + 132 + ], + "score": 1.0, + "content": "Chelsea Finn, Paul Christiano, Pieter Abbeel, and Sergey Levine. A connection between generative adversarial", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 116, + 131, + 506, + 142 + ], + "spans": [ + { + "bbox": [ + 116, + 131, + 506, + 142 + ], + "score": 1.0, + "content": "networks, inverse reinforcement learning, and energy-based models. arXiv preprint arXiv:1611.03852, 2016a.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 108, + 149, + 504, + 170 + ], + "lines": [ + { + "bbox": [ + 105, + 147, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 147, + 505, + 162 + ], + "score": 1.0, + "content": "Chelsea Finn, Sergey Levine, and Pieter Abbeel. Guided cost learning: Deep inverse optimal control via policy", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 159, + 419, + 171 + ], + "spans": [ + { + "bbox": [ + 115, + 159, + 419, + 171 + ], + "score": 1.0, + "content": "optimization. In International Conference on Machine Learning, pp. 49–58, 2016b.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 107, + 176, + 503, + 198 + ], + "lines": [ + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "score": 1.0, + "content": "Chelsea Finn, Tianhe Yu, Tianhao Zhang, Pieter Abbeel, and Sergey Levine. One-shot visual imitation learning", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 116, + 187, + 331, + 198 + ], + "spans": [ + { + "bbox": [ + 116, + 187, + 331, + 198 + ], + "score": 1.0, + "content": "via meta-learning. arXiv preprint arXiv:1709.04905, 2017.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 106, + 204, + 504, + 226 + ], + "lines": [ + { + "bbox": [ + 106, + 204, + 506, + 217 + ], + "spans": [ + { + "bbox": [ + 106, + 204, + 506, + 217 + ], + "score": 1.0, + "content": "Justin Fu, Katie Luo, and Sergey Levine. Learning robust rewards with adversarial inverse reinforcement", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 116, + 215, + 208, + 226 + ], + "spans": [ + { + "bbox": [ + 116, + 215, + 208, + 226 + ], + "score": 1.0, + "content": "learning. In ICLR, 2018.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 106, + 232, + 505, + 263 + ], + "lines": [ + { + "bbox": [ + 105, + 232, + 505, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 505, + 244 + ], + "score": 1.0, + "content": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 115, + 242, + 505, + 255 + ], + "spans": [ + { + "bbox": [ + 115, + 242, + 505, + 255 + ], + "score": 1.0, + "content": "Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 253, + 230, + 264 + ], + "spans": [ + { + "bbox": [ + 115, + 253, + 230, + 264 + ], + "score": 1.0, + "content": "systems, pp. 2672–2680, 2014.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 270, + 505, + 301 + ], + "lines": [ + { + "bbox": [ + 105, + 269, + 506, + 283 + ], + "spans": [ + { + "bbox": [ + 105, + 269, + 506, + 283 + ], + "score": 1.0, + "content": "Todd Hester, Matej Vecerik, Olivier Pietquin, Marc Lanctot, Tom Schaul, Bilal Piot, Dan Horgan, John Quan,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 280, + 506, + 292 + ], + "spans": [ + { + "bbox": [ + 115, + 280, + 506, + 292 + ], + "score": 1.0, + "content": "Andrew Sendonaris, Ian Osband, Gabriel Dulac-Arnold, John Agapiou, Joel Z. Leibo, and Audrunas Gruslys.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 291, + 313, + 302 + ], + "spans": [ + { + "bbox": [ + 116, + 291, + 313, + 302 + ], + "score": 1.0, + "content": "Deep q-learning from demonstrations. In AAAI, 2018.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 106, + 308, + 504, + 330 + ], + "lines": [ + { + "bbox": [ + 106, + 308, + 505, + 320 + ], + "spans": [ + { + "bbox": [ + 106, + 308, + 505, + 320 + ], + "score": 1.0, + "content": "Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in Neural Information", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 116, + 318, + 271, + 330 + ], + "spans": [ + { + "bbox": [ + 116, + 318, + 271, + 330 + ], + "score": 1.0, + "content": "Processing Systems, pp. 4565–4573, 2016.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 106, + 335, + 503, + 357 + ], + "lines": [ + { + "bbox": [ + 106, + 336, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 505, + 347 + ], + "score": 1.0, + "content": "Dan Horgan, John Quan, David Budden, Gabriel Barth-Maron, Matteo Hessel, Hado Van Hasselt, and David", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 346, + 439, + 358 + ], + "spans": [ + { + "bbox": [ + 115, + 346, + 439, + 358 + ], + "score": 1.0, + "content": "Silver. Distributed prioritized experience replay. arXiv preprint arXiv:1803.00933, 2018.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 107, + 363, + 503, + 385 + ], + "lines": [ + { + "bbox": [ + 105, + 363, + 505, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 505, + 376 + ], + "score": 1.0, + "content": "Mitsuo Kawato, Francesca Gandolfo, Hiroaki Gomi, and Yasuhiro Wada. Teaching by showing in kendama", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 116, + 375, + 299, + 386 + ], + "spans": [ + { + "bbox": [ + 116, + 375, + 299, + 386 + ], + "score": 1.0, + "content": "based on optimization principle. In ICANN. 1994.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5 + }, + { + "type": "text", + "bbox": [ + 106, + 392, + 505, + 413 + ], + "lines": [ + { + "bbox": [ + 106, + 392, + 506, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 506, + 404 + ], + "score": 1.0, + "content": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 401, + 141, + 413 + ], + "spans": [ + { + "bbox": [ + 115, + 401, + 141, + 413 + ], + "score": 1.0, + "content": "2014.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 107, + 419, + 504, + 441 + ], + "lines": [ + { + "bbox": [ + 106, + 419, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 106, + 419, + 506, + 432 + ], + "score": 1.0, + "content": "Yunzhu Li, Jiaming Song, and Stefano Ermon. Infogail: Interpretable imitation learning from visual demonstra-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 116, + 430, + 196, + 441 + ], + "spans": [ + { + "bbox": [ + 116, + 430, + 196, + 441 + ], + "score": 1.0, + "content": "tions. In NIPS, 2017.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 105, + 447, + 504, + 469 + ], + "lines": [ + { + "bbox": [ + 105, + 447, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 505, + 461 + ], + "score": 1.0, + "content": "Josh Merel, Yuval Tassa, Sriram Srinivasan, Jay Lemmon, Ziyu Wang, Greg Wayne, and Nicolas Heess. Learning", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 457, + 492, + 469 + ], + "spans": [ + { + "bbox": [ + 116, + 457, + 492, + 469 + ], + "score": 1.0, + "content": "human behaviors from motion capture by adversarial imitation. arXiv preprint arXiv:1707.02201, 2017.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 106, + 475, + 504, + 507 + ], + "lines": [ + { + "bbox": [ + 106, + 475, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 475, + 505, + 487 + ], + "score": 1.0, + "content": "Hiroyuki Miyamoto, Stefan Schaal, Francesca Gandolfo, Hiroaki Gomi, Yasuharu Koike, Rieko Osu, Eri", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 484, + 506, + 498 + ], + "spans": [ + { + "bbox": [ + 115, + 484, + 506, + 498 + ], + "score": 1.0, + "content": "Nakano, Yasuhiro Wada, and Mitsuo Kawato. A kendama learning robot based on bi-directional theory.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 495, + 203, + 507 + ], + "spans": [ + { + "bbox": [ + 115, + 495, + 203, + 507 + ], + "score": 1.0, + "content": "Neural networks, 1996.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 106, + 513, + 504, + 535 + ], + "lines": [ + { + "bbox": [ + 105, + 512, + 505, + 526 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 505, + 526 + ], + "score": 1.0, + "content": "Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 523, + 252, + 535 + ], + "spans": [ + { + "bbox": [ + 116, + 523, + 252, + 535 + ], + "score": 1.0, + "content": "adversarial networks. In ICLR, 2018.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 105, + 541, + 504, + 553 + ], + "lines": [ + { + "bbox": [ + 106, + 541, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 541, + 505, + 554 + ], + "score": 1.0, + "content": "Andrew Y Ng, Stuart J Russell, et al. Algorithms for inverse reinforcement learning. In Icml, pp. 663–670, 2000.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 106, + 559, + 504, + 590 + ], + "lines": [ + { + "bbox": [ + 106, + 560, + 505, + 570 + ], + "spans": [ + { + "bbox": [ + 106, + 560, + 505, + 570 + ], + "score": 1.0, + "content": "Xue Bin Peng, Angjoo Kanazawa, Sam Toyer, Pieter Abbeel, and Sergey Levine. Variational discriminator", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 570, + 505, + 582 + ], + "spans": [ + { + "bbox": [ + 116, + 570, + 505, + 582 + ], + "score": 1.0, + "content": "bottleneck: Improving imitation learning, inverse rl, and gans by constraining information flow. arXiv preprint", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 580, + 209, + 590 + ], + "spans": [ + { + "bbox": [ + 115, + 580, + 209, + 590 + ], + "score": 1.0, + "content": "arXiv:1810.00821, 2018.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36 + }, + { + "type": "text", + "bbox": [ + 107, + 597, + 504, + 628 + ], + "lines": [ + { + "bbox": [ + 105, + 597, + 506, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 506, + 609 + ], + "score": 1.0, + "content": "Tobias Pohlen, Bilal Piot, Todd Hester, Mohammad Gheshlaghi Azar, Dan Horgan, David Budden, Gabriel", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 606, + 506, + 620 + ], + "spans": [ + { + "bbox": [ + 115, + 606, + 506, + 620 + ], + "score": 1.0, + "content": "Barth-Maron, Hado van Hasselt, John Quan, Mel Vecerík, et al. Observe and look further: Achieving ˇ", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 116, + 617, + 381, + 629 + ], + "spans": [ + { + "bbox": [ + 116, + 617, + 381, + 629 + ], + "score": 1.0, + "content": "consistent performance on atari. arXiv preprint arXiv:1805.11593, 2018.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 104, + 635, + 504, + 657 + ], + "lines": [ + { + "bbox": [ + 106, + 635, + 505, + 647 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 505, + 647 + ], + "score": 1.0, + "content": "Dean A Pomerleau. Alvinn: An autonomous land vehicle in a neural network. In Advances in neural information", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 646, + 261, + 657 + ], + "spans": [ + { + "bbox": [ + 115, + 646, + 261, + 657 + ], + "score": 1.0, + "content": "processing systems, pp. 305–313, 1989.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + }, + { + "type": "text", + "bbox": [ + 106, + 663, + 504, + 694 + ], + "lines": [ + { + "bbox": [ + 106, + 663, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 106, + 663, + 505, + 675 + ], + "score": 1.0, + "content": "Rouhollah Rahmatizadeh, Pooya Abolghasemi, Ladislau Bölöni, and Sergey Levine. Vision-based multi-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 674, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 115, + 674, + 505, + 685 + ], + "score": 1.0, + "content": "task manipulation for inexpensive robots using end-to-end learning from demonstration. In 2018 IEEE", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 683, + 449, + 695 + ], + "spans": [ + { + "bbox": [ + 115, + 683, + 449, + 695 + ], + "score": 1.0, + "content": "International Conference on Robotics and Automation (ICRA), pp. 3758–3765. IEEE, 2018.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44 + }, + { + "type": "text", + "bbox": [ + 107, + 701, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 107, + 702, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 107, + 702, + 505, + 712 + ], + "score": 1.0, + "content": "Aravind Rajeswaran, Vikash Kumar, Abhishek Gupta, Giulia Vezzani, John Schulman, Emanuel Todorov, and", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 116, + 712, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 116, + 712, + 506, + 723 + ], + "score": 1.0, + "content": "Sergey Levine. Learning complex dexterous manipulation with deep reinforcement learning and demonstra-", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 116, + 721, + 286, + 733 + ], + "spans": [ + { + "bbox": [ + 116, + 721, + 286, + 733 + ], + "score": 1.0, + "content": "tions. arXiv preprint arXiv:1709.10087, 2017.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "10", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 83, + 504, + 113 + ], + "lines": [ + { + "bbox": [ + 106, + 83, + 505, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 505, + 94 + ], + "score": 1.0, + "content": "Yan Duan, Marcin Andrychowicz, Bradly Stadie, OpenAI Jonathan Ho, Jonas Schneider, Ilya Sutskever, Pieter", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 92, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 115, + 92, + 505, + 105 + ], + "score": 1.0, + "content": "Abbeel, and Wojciech Zaremba. One-shot imitation learning. In Advances in neural information processing", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 104, + 230, + 114 + ], + "spans": [ + { + "bbox": [ + 115, + 104, + 230, + 114 + ], + "score": 1.0, + "content": "systems, pp. 1087–1098, 2017.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 106, + 83, + 505, + 114 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 120, + 504, + 142 + ], + "lines": [ + { + "bbox": [ + 107, + 121, + 505, + 132 + ], + "spans": [ + { + "bbox": [ + 107, + 121, + 505, + 132 + ], + "score": 1.0, + "content": "Chelsea Finn, Paul Christiano, Pieter Abbeel, and Sergey Levine. A connection between generative adversarial", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 116, + 131, + 506, + 142 + ], + "spans": [ + { + "bbox": [ + 116, + 131, + 506, + 142 + ], + "score": 1.0, + "content": "networks, inverse reinforcement learning, and energy-based models. arXiv preprint arXiv:1611.03852, 2016a.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5, + "bbox_fs": [ + 107, + 121, + 506, + 142 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 149, + 504, + 170 + ], + "lines": [ + { + "bbox": [ + 105, + 147, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 147, + 505, + 162 + ], + "score": 1.0, + "content": "Chelsea Finn, Sergey Levine, and Pieter Abbeel. Guided cost learning: Deep inverse optimal control via policy", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 159, + 419, + 171 + ], + "spans": [ + { + "bbox": [ + 115, + 159, + 419, + 171 + ], + "score": 1.0, + "content": "optimization. In International Conference on Machine Learning, pp. 49–58, 2016b.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5, + "bbox_fs": [ + 105, + 147, + 505, + 171 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 176, + 503, + 198 + ], + "lines": [ + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "score": 1.0, + "content": "Chelsea Finn, Tianhe Yu, Tianhao Zhang, Pieter Abbeel, and Sergey Levine. One-shot visual imitation learning", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 116, + 187, + 331, + 198 + ], + "spans": [ + { + "bbox": [ + 116, + 187, + 331, + 198 + ], + "score": 1.0, + "content": "via meta-learning. arXiv preprint arXiv:1709.04905, 2017.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5, + "bbox_fs": [ + 105, + 175, + 505, + 198 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 204, + 504, + 226 + ], + "lines": [ + { + "bbox": [ + 106, + 204, + 506, + 217 + ], + "spans": [ + { + "bbox": [ + 106, + 204, + 506, + 217 + ], + "score": 1.0, + "content": "Justin Fu, Katie Luo, and Sergey Levine. Learning robust rewards with adversarial inverse reinforcement", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 116, + 215, + 208, + 226 + ], + "spans": [ + { + "bbox": [ + 116, + 215, + 208, + 226 + ], + "score": 1.0, + "content": "learning. In ICLR, 2018.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5, + "bbox_fs": [ + 106, + 204, + 506, + 226 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 232, + 505, + 263 + ], + "lines": [ + { + "bbox": [ + 105, + 232, + 505, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 505, + 244 + ], + "score": 1.0, + "content": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 115, + 242, + 505, + 255 + ], + "spans": [ + { + "bbox": [ + 115, + 242, + 505, + 255 + ], + "score": 1.0, + "content": "Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 253, + 230, + 264 + ], + "spans": [ + { + "bbox": [ + 115, + 253, + 230, + 264 + ], + "score": 1.0, + "content": "systems, pp. 2672–2680, 2014.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 232, + 505, + 264 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 270, + 505, + 301 + ], + "lines": [ + { + "bbox": [ + 105, + 269, + 506, + 283 + ], + "spans": [ + { + "bbox": [ + 105, + 269, + 506, + 283 + ], + "score": 1.0, + "content": "Todd Hester, Matej Vecerik, Olivier Pietquin, Marc Lanctot, Tom Schaul, Bilal Piot, Dan Horgan, John Quan,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 280, + 506, + 292 + ], + "spans": [ + { + "bbox": [ + 115, + 280, + 506, + 292 + ], + "score": 1.0, + "content": "Andrew Sendonaris, Ian Osband, Gabriel Dulac-Arnold, John Agapiou, Joel Z. Leibo, and Audrunas Gruslys.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 291, + 313, + 302 + ], + "spans": [ + { + "bbox": [ + 116, + 291, + 313, + 302 + ], + "score": 1.0, + "content": "Deep q-learning from demonstrations. In AAAI, 2018.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 269, + 506, + 302 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 308, + 504, + 330 + ], + "lines": [ + { + "bbox": [ + 106, + 308, + 505, + 320 + ], + "spans": [ + { + "bbox": [ + 106, + 308, + 505, + 320 + ], + "score": 1.0, + "content": "Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in Neural Information", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 116, + 318, + 271, + 330 + ], + "spans": [ + { + "bbox": [ + 116, + 318, + 271, + 330 + ], + "score": 1.0, + "content": "Processing Systems, pp. 4565–4573, 2016.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5, + "bbox_fs": [ + 106, + 308, + 505, + 330 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 335, + 503, + 357 + ], + "lines": [ + { + "bbox": [ + 106, + 336, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 505, + 347 + ], + "score": 1.0, + "content": "Dan Horgan, John Quan, David Budden, Gabriel Barth-Maron, Matteo Hessel, Hado Van Hasselt, and David", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 346, + 439, + 358 + ], + "spans": [ + { + "bbox": [ + 115, + 346, + 439, + 358 + ], + "score": 1.0, + "content": "Silver. Distributed prioritized experience replay. arXiv preprint arXiv:1803.00933, 2018.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5, + "bbox_fs": [ + 106, + 336, + 505, + 358 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 363, + 503, + 385 + ], + "lines": [ + { + "bbox": [ + 105, + 363, + 505, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 505, + 376 + ], + "score": 1.0, + "content": "Mitsuo Kawato, Francesca Gandolfo, Hiroaki Gomi, and Yasuhiro Wada. Teaching by showing in kendama", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 116, + 375, + 299, + 386 + ], + "spans": [ + { + "bbox": [ + 116, + 375, + 299, + 386 + ], + "score": 1.0, + "content": "based on optimization principle. In ICANN. 1994.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 363, + 505, + 386 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 392, + 505, + 413 + ], + "lines": [ + { + "bbox": [ + 106, + 392, + 506, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 506, + 404 + ], + "score": 1.0, + "content": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 401, + 141, + 413 + ], + "spans": [ + { + "bbox": [ + 115, + 401, + 141, + 413 + ], + "score": 1.0, + "content": "2014.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5, + "bbox_fs": [ + 106, + 392, + 506, + 413 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 419, + 504, + 441 + ], + "lines": [ + { + "bbox": [ + 106, + 419, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 106, + 419, + 506, + 432 + ], + "score": 1.0, + "content": "Yunzhu Li, Jiaming Song, and Stefano Ermon. Infogail: Interpretable imitation learning from visual demonstra-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 116, + 430, + 196, + 441 + ], + "spans": [ + { + "bbox": [ + 116, + 430, + 196, + 441 + ], + "score": 1.0, + "content": "tions. In NIPS, 2017.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5, + "bbox_fs": [ + 106, + 419, + 506, + 441 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 447, + 504, + 469 + ], + "lines": [ + { + "bbox": [ + 105, + 447, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 505, + 461 + ], + "score": 1.0, + "content": "Josh Merel, Yuval Tassa, Sriram Srinivasan, Jay Lemmon, Ziyu Wang, Greg Wayne, and Nicolas Heess. Learning", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 457, + 492, + 469 + ], + "spans": [ + { + "bbox": [ + 116, + 457, + 492, + 469 + ], + "score": 1.0, + "content": "human behaviors from motion capture by adversarial imitation. arXiv preprint arXiv:1707.02201, 2017.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 447, + 505, + 469 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 475, + 504, + 507 + ], + "lines": [ + { + "bbox": [ + 106, + 475, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 475, + 505, + 487 + ], + "score": 1.0, + "content": "Hiroyuki Miyamoto, Stefan Schaal, Francesca Gandolfo, Hiroaki Gomi, Yasuharu Koike, Rieko Osu, Eri", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 484, + 506, + 498 + ], + "spans": [ + { + "bbox": [ + 115, + 484, + 506, + 498 + ], + "score": 1.0, + "content": "Nakano, Yasuhiro Wada, and Mitsuo Kawato. A kendama learning robot based on bi-directional theory.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 495, + 203, + 507 + ], + "spans": [ + { + "bbox": [ + 115, + 495, + 203, + 507 + ], + "score": 1.0, + "content": "Neural networks, 1996.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30, + "bbox_fs": [ + 106, + 475, + 506, + 507 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 513, + 504, + 535 + ], + "lines": [ + { + "bbox": [ + 105, + 512, + 505, + 526 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 505, + 526 + ], + "score": 1.0, + "content": "Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 523, + 252, + 535 + ], + "spans": [ + { + "bbox": [ + 116, + 523, + 252, + 535 + ], + "score": 1.0, + "content": "adversarial networks. In ICLR, 2018.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 512, + 505, + 535 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 541, + 504, + 553 + ], + "lines": [ + { + "bbox": [ + 106, + 541, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 541, + 505, + 554 + ], + "score": 1.0, + "content": "Andrew Y Ng, Stuart J Russell, et al. Algorithms for inverse reinforcement learning. In Icml, pp. 663–670, 2000.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34, + "bbox_fs": [ + 106, + 541, + 505, + 554 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 559, + 504, + 590 + ], + "lines": [ + { + "bbox": [ + 106, + 560, + 505, + 570 + ], + "spans": [ + { + "bbox": [ + 106, + 560, + 505, + 570 + ], + "score": 1.0, + "content": "Xue Bin Peng, Angjoo Kanazawa, Sam Toyer, Pieter Abbeel, and Sergey Levine. Variational discriminator", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 570, + 505, + 582 + ], + "spans": [ + { + "bbox": [ + 116, + 570, + 505, + 582 + ], + "score": 1.0, + "content": "bottleneck: Improving imitation learning, inverse rl, and gans by constraining information flow. arXiv preprint", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 580, + 209, + 590 + ], + "spans": [ + { + "bbox": [ + 115, + 580, + 209, + 590 + ], + "score": 1.0, + "content": "arXiv:1810.00821, 2018.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36, + "bbox_fs": [ + 106, + 560, + 505, + 590 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 597, + 504, + 628 + ], + "lines": [ + { + "bbox": [ + 105, + 597, + 506, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 506, + 609 + ], + "score": 1.0, + "content": "Tobias Pohlen, Bilal Piot, Todd Hester, Mohammad Gheshlaghi Azar, Dan Horgan, David Budden, Gabriel", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 606, + 506, + 620 + ], + "spans": [ + { + "bbox": [ + 115, + 606, + 506, + 620 + ], + "score": 1.0, + "content": "Barth-Maron, Hado van Hasselt, John Quan, Mel Vecerík, et al. Observe and look further: Achieving ˇ", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 116, + 617, + 381, + 629 + ], + "spans": [ + { + "bbox": [ + 116, + 617, + 381, + 629 + ], + "score": 1.0, + "content": "consistent performance on atari. arXiv preprint arXiv:1805.11593, 2018.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39, + "bbox_fs": [ + 105, + 597, + 506, + 629 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 635, + 504, + 657 + ], + "lines": [ + { + "bbox": [ + 106, + 635, + 505, + 647 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 505, + 647 + ], + "score": 1.0, + "content": "Dean A Pomerleau. Alvinn: An autonomous land vehicle in a neural network. In Advances in neural information", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 646, + 261, + 657 + ], + "spans": [ + { + "bbox": [ + 115, + 646, + 261, + 657 + ], + "score": 1.0, + "content": "processing systems, pp. 305–313, 1989.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5, + "bbox_fs": [ + 106, + 635, + 505, + 657 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 663, + 504, + 694 + ], + "lines": [ + { + "bbox": [ + 106, + 663, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 106, + 663, + 505, + 675 + ], + "score": 1.0, + "content": "Rouhollah Rahmatizadeh, Pooya Abolghasemi, Ladislau Bölöni, and Sergey Levine. Vision-based multi-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 674, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 115, + 674, + 505, + 685 + ], + "score": 1.0, + "content": "task manipulation for inexpensive robots using end-to-end learning from demonstration. In 2018 IEEE", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 683, + 449, + 695 + ], + "spans": [ + { + "bbox": [ + 115, + 683, + 449, + 695 + ], + "score": 1.0, + "content": "International Conference on Robotics and Automation (ICRA), pp. 3758–3765. IEEE, 2018.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44, + "bbox_fs": [ + 106, + 663, + 505, + 695 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 701, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 107, + 702, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 107, + 702, + 505, + 712 + ], + "score": 1.0, + "content": "Aravind Rajeswaran, Vikash Kumar, Abhishek Gupta, Giulia Vezzani, John Schulman, Emanuel Todorov, and", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 116, + 712, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 116, + 712, + 506, + 723 + ], + "score": 1.0, + "content": "Sergey Levine. Learning complex dexterous manipulation with deep reinforcement learning and demonstra-", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 116, + 721, + 286, + 733 + ], + "spans": [ + { + "bbox": [ + 116, + 721, + 286, + 733 + ], + "score": 1.0, + "content": "tions. arXiv preprint arXiv:1709.10087, 2017.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47, + "bbox_fs": [ + 107, + 702, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 83, + 504, + 104 + ], + "lines": [ + { + "bbox": [ + 106, + 83, + 505, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 505, + 94 + ], + "score": 1.0, + "content": "Scott Reed, Yusuf Aytar, Ziyu Wang, Tom Paine, Aäron van den Oord, Tobias Pfaff, Sergio Gomez, Alexander", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 116, + 94, + 455, + 104 + ], + "spans": [ + { + "bbox": [ + 116, + 94, + 455, + 104 + ], + "score": 1.0, + "content": "Novikov, David Budden, and Oriol Vinyals. Visual imitation with a minimal adversary. 2018.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 108, + 111, + 503, + 142 + ], + "lines": [ + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "spans": [ + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "score": 1.0, + "content": "Stéphane Ross, Geoffrey Gordon, and Drew Bagnell. A reduction of imitation learning and structured prediction", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 121, + 505, + 133 + ], + "spans": [ + { + "bbox": [ + 115, + 121, + 505, + 133 + ], + "score": 1.0, + "content": "to no-regret online learning. In Proceedings of the fourteenth international conference on artificial intelligence", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 116, + 131, + 240, + 142 + ], + "spans": [ + { + "bbox": [ + 116, + 131, + 240, + 142 + ], + "score": 1.0, + "content": "and statistics, pp. 627–635, 2011.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 108, + 149, + 504, + 170 + ], + "lines": [ + { + "bbox": [ + 105, + 148, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 505, + 161 + ], + "score": 1.0, + "content": "Fumihiro Sasaki, Tetsuya Yohira, and Atsuo Kawaguchi. Sample efficient imitation learning for continuous", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 158, + 171, + 169 + ], + "spans": [ + { + "bbox": [ + 115, + 158, + 171, + 169 + ], + "score": 1.0, + "content": "control. 2018.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 106, + 176, + 327, + 187 + ], + "lines": [ + { + "bbox": [ + 106, + 177, + 327, + 188 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 327, + 188 + ], + "score": 1.0, + "content": "Stefan Schaal. Learning from demonstration. In NIPS, 1997.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 105, + 194, + 504, + 216 + ], + "lines": [ + { + "bbox": [ + 106, + 195, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 106, + 195, + 505, + 206 + ], + "score": 1.0, + "content": "David Silver, Guy Lever, Nicolas Heess, Thomas Degris, Daan Wierstra, and Martin Riedmiller. Deterministic", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 205, + 275, + 216 + ], + "spans": [ + { + "bbox": [ + 115, + 205, + 275, + 216 + ], + "score": 1.0, + "content": "policy gradient algorithms. In ICML, 2014.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 105, + 222, + 504, + 244 + ], + "lines": [ + { + "bbox": [ + 106, + 223, + 504, + 234 + ], + "spans": [ + { + "bbox": [ + 106, + 223, + 504, + 234 + ], + "score": 1.0, + "content": "Avi Singh, Larry Yang, Kristian Hartikainen, Chelsea Finn, and Sergey Levine. End-to-end robotic reinforcement", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 232, + 399, + 244 + ], + "spans": [ + { + "bbox": [ + 115, + 232, + 399, + 244 + ], + "score": 1.0, + "content": "learning without reward engineering. arXiv preprint arXiv:1904.07854, 2019.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 106, + 250, + 504, + 271 + ], + "lines": [ + { + "bbox": [ + 105, + 248, + 505, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 248, + 505, + 263 + ], + "score": 1.0, + "content": "Bradly C Stadie, Pieter Abbeel, and Ilya Sutskever. Third-person imitation learning. arXiv preprint", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 260, + 210, + 271 + ], + "spans": [ + { + "bbox": [ + 115, + 260, + 210, + 271 + ], + "score": 1.0, + "content": "arXiv:1703.01703, 2017.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 105, + 278, + 467, + 289 + ], + "lines": [ + { + "bbox": [ + 105, + 278, + 466, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 278, + 466, + 290 + ], + "score": 1.0, + "content": "Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 296, + 506, + 317 + ], + "lines": [ + { + "bbox": [ + 106, + 296, + 505, + 307 + ], + "spans": [ + { + "bbox": [ + 106, + 296, + 505, + 307 + ], + "score": 1.0, + "content": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In 2012", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 307, + 478, + 318 + ], + "spans": [ + { + "bbox": [ + 116, + 307, + 478, + 318 + ], + "score": 1.0, + "content": "IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 5026–5033. IEEE, 2012.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 106, + 324, + 503, + 345 + ], + "lines": [ + { + "bbox": [ + 106, + 324, + 505, + 336 + ], + "spans": [ + { + "bbox": [ + 106, + 324, + 505, + 336 + ], + "score": 1.0, + "content": "Dmitry Ulyanov, Andrea Vedaldi, and Victor Lempitsky. Instance normalization: The missing ingredient for fast", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 334, + 306, + 345 + ], + "spans": [ + { + "bbox": [ + 115, + 334, + 306, + 345 + ], + "score": 1.0, + "content": "stylization. arXiv preprint arXiv:1607.08022, 2016.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 106, + 351, + 504, + 383 + ], + "lines": [ + { + "bbox": [ + 105, + 352, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 505, + 363 + ], + "score": 1.0, + "content": "Matej Vecerik, Todd Hester, Jonathan Scholz, Fumin Wang, Olivier Pietquin, Bilal Piot, Nicolas Heess, Thomas", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 363, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 116, + 363, + 505, + 373 + ], + "score": 1.0, + "content": "Rothörl, Thomas Lampe, and Martin A. Riedmiller. Leveraging demonstrations for deep reinforcement", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 116, + 373, + 351, + 383 + ], + "spans": [ + { + "bbox": [ + 116, + 373, + 351, + 383 + ], + "score": 1.0, + "content": "learning on robotics problems with sparse rewards. CoRR, 2017.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 389, + 504, + 420 + ], + "lines": [ + { + "bbox": [ + 106, + 389, + 506, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 389, + 506, + 402 + ], + "score": 1.0, + "content": "Yuke Zhu, Ziyu Wang, Josh Merel, Andrei Rusu, Tom Erez, Serkan Cabi, Saran Tunyasuvunakool, János Kramár,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 400, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 116, + 400, + 505, + 411 + ], + "score": 1.0, + "content": "Raia Hadsell, Nando de Freitas, et al. Reinforcement and imitation learning for diverse visuomotor skills. In", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 408, + 159, + 422 + ], + "spans": [ + { + "bbox": [ + 115, + 408, + 159, + 422 + ], + "score": 1.0, + "content": "RSS, 2018.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 104, + 428, + 504, + 449 + ], + "lines": [ + { + "bbox": [ + 105, + 427, + 505, + 441 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 505, + 441 + ], + "score": 1.0, + "content": "Brian D Ziebart, Andrew L Maas, J Andrew Bagnell, and Anind K Dey. Maximum entropy inverse reinforcement", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 116, + 438, + 373, + 449 + ], + "spans": [ + { + "bbox": [ + 116, + 438, + 373, + 449 + ], + "score": 1.0, + "content": "learning. In AAAI, volume 8, pp. 1433–1438. Chicago, IL, USA, 2008.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 309, + 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": [ + 106, + 83, + 504, + 104 + ], + "lines": [ + { + "bbox": [ + 106, + 83, + 505, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 505, + 94 + ], + "score": 1.0, + "content": "Scott Reed, Yusuf Aytar, Ziyu Wang, Tom Paine, Aäron van den Oord, Tobias Pfaff, Sergio Gomez, Alexander", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 116, + 94, + 455, + 104 + ], + "spans": [ + { + "bbox": [ + 116, + 94, + 455, + 104 + ], + "score": 1.0, + "content": "Novikov, David Budden, and Oriol Vinyals. Visual imitation with a minimal adversary. 2018.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 106, + 83, + 505, + 104 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 111, + 503, + 142 + ], + "lines": [ + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "spans": [ + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "score": 1.0, + "content": "Stéphane Ross, Geoffrey Gordon, and Drew Bagnell. A reduction of imitation learning and structured prediction", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 121, + 505, + 133 + ], + "spans": [ + { + "bbox": [ + 115, + 121, + 505, + 133 + ], + "score": 1.0, + "content": "to no-regret online learning. In Proceedings of the fourteenth international conference on artificial intelligence", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 116, + 131, + 240, + 142 + ], + "spans": [ + { + "bbox": [ + 116, + 131, + 240, + 142 + ], + "score": 1.0, + "content": "and statistics, pp. 627–635, 2011.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3, + "bbox_fs": [ + 106, + 111, + 505, + 142 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 149, + 504, + 170 + ], + "lines": [ + { + "bbox": [ + 105, + 148, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 505, + 161 + ], + "score": 1.0, + "content": "Fumihiro Sasaki, Tetsuya Yohira, and Atsuo Kawaguchi. Sample efficient imitation learning for continuous", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 158, + 171, + 169 + ], + "spans": [ + { + "bbox": [ + 115, + 158, + 171, + 169 + ], + "score": 1.0, + "content": "control. 2018.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5, + "bbox_fs": [ + 105, + 148, + 505, + 169 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 176, + 327, + 187 + ], + "lines": [ + { + "bbox": [ + 106, + 177, + 327, + 188 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 327, + 188 + ], + "score": 1.0, + "content": "Stefan Schaal. Learning from demonstration. In NIPS, 1997.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7, + "bbox_fs": [ + 106, + 177, + 327, + 188 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 194, + 504, + 216 + ], + "lines": [ + { + "bbox": [ + 106, + 195, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 106, + 195, + 505, + 206 + ], + "score": 1.0, + "content": "David Silver, Guy Lever, Nicolas Heess, Thomas Degris, Daan Wierstra, and Martin Riedmiller. Deterministic", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 205, + 275, + 216 + ], + "spans": [ + { + "bbox": [ + 115, + 205, + 275, + 216 + ], + "score": 1.0, + "content": "policy gradient algorithms. In ICML, 2014.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5, + "bbox_fs": [ + 106, + 195, + 505, + 216 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 222, + 504, + 244 + ], + "lines": [ + { + "bbox": [ + 106, + 223, + 504, + 234 + ], + "spans": [ + { + "bbox": [ + 106, + 223, + 504, + 234 + ], + "score": 1.0, + "content": "Avi Singh, Larry Yang, Kristian Hartikainen, Chelsea Finn, and Sergey Levine. End-to-end robotic reinforcement", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 232, + 399, + 244 + ], + "spans": [ + { + "bbox": [ + 115, + 232, + 399, + 244 + ], + "score": 1.0, + "content": "learning without reward engineering. arXiv preprint arXiv:1904.07854, 2019.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5, + "bbox_fs": [ + 106, + 223, + 504, + 244 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 250, + 504, + 271 + ], + "lines": [ + { + "bbox": [ + 105, + 248, + 505, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 248, + 505, + 263 + ], + "score": 1.0, + "content": "Bradly C Stadie, Pieter Abbeel, and Ilya Sutskever. Third-person imitation learning. arXiv preprint", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 260, + 210, + 271 + ], + "spans": [ + { + "bbox": [ + 115, + 260, + 210, + 271 + ], + "score": 1.0, + "content": "arXiv:1703.01703, 2017.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5, + "bbox_fs": [ + 105, + 248, + 505, + 271 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 278, + 467, + 289 + ], + "lines": [ + { + "bbox": [ + 105, + 278, + 466, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 278, + 466, + 290 + ], + "score": 1.0, + "content": "Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14, + "bbox_fs": [ + 105, + 278, + 466, + 290 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 296, + 506, + 317 + ], + "lines": [ + { + "bbox": [ + 106, + 296, + 505, + 307 + ], + "spans": [ + { + "bbox": [ + 106, + 296, + 505, + 307 + ], + "score": 1.0, + "content": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In 2012", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 307, + 478, + 318 + ], + "spans": [ + { + "bbox": [ + 116, + 307, + 478, + 318 + ], + "score": 1.0, + "content": "IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 5026–5033. IEEE, 2012.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5, + "bbox_fs": [ + 106, + 296, + 505, + 318 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 324, + 503, + 345 + ], + "lines": [ + { + "bbox": [ + 106, + 324, + 505, + 336 + ], + "spans": [ + { + "bbox": [ + 106, + 324, + 505, + 336 + ], + "score": 1.0, + "content": "Dmitry Ulyanov, Andrea Vedaldi, and Victor Lempitsky. Instance normalization: The missing ingredient for fast", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 334, + 306, + 345 + ], + "spans": [ + { + "bbox": [ + 115, + 334, + 306, + 345 + ], + "score": 1.0, + "content": "stylization. arXiv preprint arXiv:1607.08022, 2016.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5, + "bbox_fs": [ + 106, + 324, + 505, + 345 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 351, + 504, + 383 + ], + "lines": [ + { + "bbox": [ + 105, + 352, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 505, + 363 + ], + "score": 1.0, + "content": "Matej Vecerik, Todd Hester, Jonathan Scholz, Fumin Wang, Olivier Pietquin, Bilal Piot, Nicolas Heess, Thomas", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 363, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 116, + 363, + 505, + 373 + ], + "score": 1.0, + "content": "Rothörl, Thomas Lampe, and Martin A. Riedmiller. Leveraging demonstrations for deep reinforcement", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 116, + 373, + 351, + 383 + ], + "spans": [ + { + "bbox": [ + 116, + 373, + 351, + 383 + ], + "score": 1.0, + "content": "learning on robotics problems with sparse rewards. CoRR, 2017.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20, + "bbox_fs": [ + 105, + 352, + 505, + 383 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 389, + 504, + 420 + ], + "lines": [ + { + "bbox": [ + 106, + 389, + 506, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 389, + 506, + 402 + ], + "score": 1.0, + "content": "Yuke Zhu, Ziyu Wang, Josh Merel, Andrei Rusu, Tom Erez, Serkan Cabi, Saran Tunyasuvunakool, János Kramár,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 400, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 116, + 400, + 505, + 411 + ], + "score": 1.0, + "content": "Raia Hadsell, Nando de Freitas, et al. Reinforcement and imitation learning for diverse visuomotor skills. In", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 408, + 159, + 422 + ], + "spans": [ + { + "bbox": [ + 115, + 408, + 159, + 422 + ], + "score": 1.0, + "content": "RSS, 2018.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23, + "bbox_fs": [ + 106, + 389, + 506, + 422 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 428, + 504, + 449 + ], + "lines": [ + { + "bbox": [ + 105, + 427, + 505, + 441 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 505, + 441 + ], + "score": 1.0, + "content": "Brian D Ziebart, Andrew L Maas, J Andrew Bagnell, and Anind K Dey. Maximum entropy inverse reinforcement", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 116, + 438, + 373, + 449 + ], + "spans": [ + { + "bbox": [ + 116, + 438, + 373, + 449 + ], + "score": 1.0, + "content": "learning. In AAAI, volume 8, pp. 1433–1438. Chicago, IL, USA, 2008.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5, + "bbox_fs": [ + 105, + 427, + 505, + 449 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 274, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 276, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 276, + 95 + ], + "score": 1.0, + "content": "A SUPPLEMENTARY MATERIAL", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 107, + 105, + 317, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 105, + 319, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 319, + 117 + ], + "score": 1.0, + "content": "A.1 DETAILED DESCRIPTION OF ENVIRONMENT", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 108, + 125, + 505, + 159 + ], + "lines": [ + { + "bbox": [ + 105, + 125, + 506, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 125, + 274, + 138 + ], + "score": 1.0, + "content": "All our simulations are conducted using", + "type": "text" + }, + { + "bbox": [ + 274, + 125, + 315, + 136 + ], + "score": 0.75, + "content": "\\mathbf { M u J o C o ^ { 1 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 125, + 506, + 138 + ], + "score": 1.0, + "content": "(Todorov et al., 2012). We test our proposed", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 136, + 505, + 149 + ], + "spans": [ + { + "bbox": [ + 106, + 136, + 505, + 149 + ], + "score": 1.0, + "content": "algorithms in a variety of different envrionments using simulated Kinova Jaco2, and Sawyer robot", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 146, + 470, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 146, + 470, + 161 + ], + "score": 1.0, + "content": "arms3; see Figure 9. We use the Robotiq 2F85 gripper4 in conjuction with the Sawyer arm.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3 + }, + { + "type": "image", + "bbox": [ + 126, + 168, + 483, + 257 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 126, + 168, + 483, + 257 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 126, + 168, + 483, + 257 + ], + "spans": [ + { + "bbox": [ + 126, + 168, + 483, + 257 + ], + "score": 0.968, + "type": "image", + "image_path": "6bccf9982d118787a6c2979868292057dd3b8d908253da25a031063cb76c20dc.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 126, + 168, + 483, + 197.66666666666666 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 126, + 197.66666666666666, + 483, + 227.33333333333331 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 126, + 227.33333333333331, + 483, + 257.0 + ], + "spans": [], + "index": 7 + } + ] + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 108, + 268, + 505, + 291 + ], + "lines": [ + { + "bbox": [ + 106, + 269, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 106, + 269, + 399, + 282 + ], + "score": 1.0, + "content": "Figure 9: Two work spaces, Jaco (left) which uses the Jaco arm and is", + "type": "text" + }, + { + "bbox": [ + 400, + 269, + 451, + 280 + ], + "score": 0.88, + "content": "2 0 \\times 2 0 ~ \\mathrm { c m }", + "type": "inline_equation" + }, + { + "bbox": [ + 451, + 269, + 505, + 282 + ], + "score": 1.0, + "content": ", and Sawyer", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 280, + 505, + 293 + ], + "spans": [ + { + "bbox": [ + 106, + 280, + 452, + 293 + ], + "score": 1.0, + "content": "(right) which uses the Sawyer arm and more closely resembles a real robot cage and is", + "type": "text" + }, + { + "bbox": [ + 453, + 280, + 501, + 290 + ], + "score": 0.88, + "content": "3 5 \\times 3 5 \\mathrm { c m }", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 280, + 505, + 293 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 107, + 301, + 505, + 346 + ], + "lines": [ + { + "bbox": [ + 105, + 301, + 505, + 314 + ], + "spans": [ + { + "bbox": [ + 105, + 301, + 505, + 314 + ], + "score": 1.0, + "content": "To provide demonstrations, we use the SpaceNavigator 3D motion controller5 to set Cartesion", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 313, + 507, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 507, + 326 + ], + "score": 1.0, + "content": "velocities of the robot arm. The gripper actions are implemented via the buttons on the controller.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 323, + 506, + 336 + ], + "spans": [ + { + "bbox": [ + 105, + 323, + 506, + 336 + ], + "score": 1.0, + "content": "All demonstrations in our experiments are provided via human teleoperation and we collected 100", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 334, + 254, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 254, + 347 + ], + "score": 1.0, + "content": "demonstrations for each experiment.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 107, + 352, + 506, + 396 + ], + "lines": [ + { + "bbox": [ + 106, + 352, + 506, + 364 + ], + "spans": [ + { + "bbox": [ + 106, + 352, + 506, + 364 + ], + "score": 1.0, + "content": "Jaco: When using the Jaco arm, we use joint velocity control (9DOF) where we control all 6 joints of", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 363, + 506, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 363, + 506, + 375 + ], + "score": 1.0, + "content": "arm and all 3 joints of the hand. The simulation is run with a numerical time step of 10 milliseconds,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 374, + 506, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 506, + 387 + ], + "score": 1.0, + "content": "integrating 5 steps, to get a control frequency of 20HZ. The agent uses a frontal camera of size", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 384, + 501, + 397 + ], + "spans": [ + { + "bbox": [ + 106, + 385, + 140, + 395 + ], + "score": 0.89, + "content": "6 4 \\times 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 384, + 501, + 397 + ], + "score": 1.0, + "content": "(see Figure 10(a)). For a full list of observations the agent sees, please refer to Table 2(a).", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5 + }, + { + "type": "image", + "bbox": [ + 126, + 405, + 480, + 526 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 126, + 405, + 480, + 526 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 126, + 405, + 480, + 526 + ], + "spans": [ + { + "bbox": [ + 126, + 405, + 480, + 526 + ], + "score": 0.973, + "type": "image", + "image_path": "b6bc13e4b98119453319a74daf7dde365754b163a2a6e1e98dd817c38debb41d.jpg" + } + ] + } + ], + "index": 19, + "virtual_lines": [ + { + "bbox": [ + 126, + 405, + 480, + 445.3333333333333 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 126, + 445.3333333333333, + 480, + 485.66666666666663 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 126, + 485.66666666666663, + 480, + 526.0 + ], + "spans": [], + "index": 20 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 196, + 538, + 414, + 550 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 194, + 536, + 416, + 552 + ], + "spans": [ + { + "bbox": [ + 194, + 536, + 416, + 552 + ], + "score": 1.0, + "content": "Figure 10: Illustration of the pixels inputs to the agent.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + } + ], + "index": 20.0 + }, + { + "type": "text", + "bbox": [ + 106, + 559, + 505, + 626 + ], + "lines": [ + { + "bbox": [ + 106, + 560, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 106, + 560, + 505, + 572 + ], + "score": 1.0, + "content": "Sawyer: When using the Sawyer arm, we use Cartesian velocity control (6DOF) for the robot arm", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 570, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 505, + 583 + ], + "score": 1.0, + "content": "and add one additional action for the gripper resulting in 7 degrees of freedom. The simulation is", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 581, + 506, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 506, + 595 + ], + "score": 1.0, + "content": "run with a numerical time step of 10 milliseconds, integrating 10 steps, to get a control frequency", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 592, + 506, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 322, + 605 + ], + "score": 1.0, + "content": "of 10HZ. The agent uses two frontal cameras of size", + "type": "text" + }, + { + "bbox": [ + 323, + 593, + 357, + 603 + ], + "score": 0.93, + "content": "6 4 \\times 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 592, + 506, + 605 + ], + "score": 1.0, + "content": "situated on the left and right side of", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 262, + 617 + ], + "score": 1.0, + "content": "the robot cage respectively (see Figure", + "type": "text" + }, + { + "bbox": [ + 262, + 604, + 295, + 615 + ], + "score": 0.68, + "content": "1 0 ( \\mathrm { b } , \\mathrm { c } ) ,", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 604, + 505, + 617 + ], + "score": 1.0, + "content": "). For a full list of observations the agent sees, please", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 615, + 184, + 627 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 184, + 627 + ], + "score": 1.0, + "content": "refer to Table 2(b).", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 106, + 631, + 504, + 665 + ], + "lines": [ + { + "bbox": [ + 105, + 631, + 506, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 631, + 506, + 644 + ], + "score": 1.0, + "content": "For all environments considered in this paper, we provide sparse rewards (i.e. if task is accomplished,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 643, + 505, + 655 + ], + "spans": [ + { + "bbox": [ + 106, + 643, + 505, + 655 + ], + "score": 1.0, + "content": "the reward is 1 and 0 otherwise). In experiments regards our proposed methods, rewards are only", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 654, + 343, + 666 + ], + "spans": [ + { + "bbox": [ + 106, + 654, + 343, + 666 + ], + "score": 1.0, + "content": "used for evaluation purposes and not for training the agent.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 672, + 401, + 732 + ], + "lines": [ + { + "bbox": [ + 118, + 672, + 184, + 685 + ], + "spans": [ + { + "bbox": [ + 118, + 672, + 184, + 685 + ], + "score": 1.0, + "content": "1www.mujoco.org", + "type": "text" + } + ] + }, + { + "bbox": [ + 114, + 678, + 404, + 699 + ], + "spans": [ + { + "bbox": [ + 114, + 678, + 404, + 699 + ], + "score": 1.0, + "content": "2https://www.kinovarobotics.com/en/products/assistive-technologies/", + "type": "text" + } + ] + }, + { + "bbox": [ + 116, + 698, + 289, + 715 + ], + "spans": [ + { + "bbox": [ + 116, + 698, + 289, + 715 + ], + "score": 1.0, + "content": "3https://www.rethinkrobotics.com/sawyer/", + "type": "text" + } + ] + }, + { + "bbox": [ + 116, + 709, + 379, + 726 + ], + "spans": [ + { + "bbox": [ + 116, + 709, + 379, + 726 + ], + "score": 1.0, + "content": "4https://robotiq.com/products/2f85-140-adaptive-robot-gripper", + "type": "text" + } + ] + }, + { + "bbox": [ + 117, + 720, + 335, + 734 + ], + "spans": [ + { + "bbox": [ + 117, + 720, + 335, + 734 + ], + "score": 1.0, + "content": "5https://www.3dconnexion.com/spacemouse_compact/en/", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 274, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 276, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 276, + 95 + ], + "score": 1.0, + "content": "A SUPPLEMENTARY MATERIAL", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 107, + 105, + 317, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 105, + 319, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 319, + 117 + ], + "score": 1.0, + "content": "A.1 DETAILED DESCRIPTION OF ENVIRONMENT", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 108, + 125, + 505, + 159 + ], + "lines": [ + { + "bbox": [ + 105, + 125, + 506, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 125, + 274, + 138 + ], + "score": 1.0, + "content": "All our simulations are conducted using", + "type": "text" + }, + { + "bbox": [ + 274, + 125, + 315, + 136 + ], + "score": 0.75, + "content": "\\mathbf { M u J o C o ^ { 1 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 125, + 506, + 138 + ], + "score": 1.0, + "content": "(Todorov et al., 2012). We test our proposed", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 136, + 505, + 149 + ], + "spans": [ + { + "bbox": [ + 106, + 136, + 505, + 149 + ], + "score": 1.0, + "content": "algorithms in a variety of different envrionments using simulated Kinova Jaco2, and Sawyer robot", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 146, + 470, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 146, + 470, + 161 + ], + "score": 1.0, + "content": "arms3; see Figure 9. We use the Robotiq 2F85 gripper4 in conjuction with the Sawyer arm.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3, + "bbox_fs": [ + 105, + 125, + 506, + 161 + ] + }, + { + "type": "image", + "bbox": [ + 126, + 168, + 483, + 257 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 126, + 168, + 483, + 257 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 126, + 168, + 483, + 257 + ], + "spans": [ + { + "bbox": [ + 126, + 168, + 483, + 257 + ], + "score": 0.968, + "type": "image", + "image_path": "6bccf9982d118787a6c2979868292057dd3b8d908253da25a031063cb76c20dc.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 126, + 168, + 483, + 197.66666666666666 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 126, + 197.66666666666666, + 483, + 227.33333333333331 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 126, + 227.33333333333331, + 483, + 257.0 + ], + "spans": [], + "index": 7 + } + ] + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 108, + 268, + 505, + 291 + ], + "lines": [ + { + "bbox": [ + 106, + 269, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 106, + 269, + 399, + 282 + ], + "score": 1.0, + "content": "Figure 9: Two work spaces, Jaco (left) which uses the Jaco arm and is", + "type": "text" + }, + { + "bbox": [ + 400, + 269, + 451, + 280 + ], + "score": 0.88, + "content": "2 0 \\times 2 0 ~ \\mathrm { c m }", + "type": "inline_equation" + }, + { + "bbox": [ + 451, + 269, + 505, + 282 + ], + "score": 1.0, + "content": ", and Sawyer", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 280, + 505, + 293 + ], + "spans": [ + { + "bbox": [ + 106, + 280, + 452, + 293 + ], + "score": 1.0, + "content": "(right) which uses the Sawyer arm and more closely resembles a real robot cage and is", + "type": "text" + }, + { + "bbox": [ + 453, + 280, + 501, + 290 + ], + "score": 0.88, + "content": "3 5 \\times 3 5 \\mathrm { c m }", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 280, + 505, + 293 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5, + "bbox_fs": [ + 106, + 269, + 505, + 293 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 301, + 505, + 346 + ], + "lines": [ + { + "bbox": [ + 105, + 301, + 505, + 314 + ], + "spans": [ + { + "bbox": [ + 105, + 301, + 505, + 314 + ], + "score": 1.0, + "content": "To provide demonstrations, we use the SpaceNavigator 3D motion controller5 to set Cartesion", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 313, + 507, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 507, + 326 + ], + "score": 1.0, + "content": "velocities of the robot arm. The gripper actions are implemented via the buttons on the controller.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 323, + 506, + 336 + ], + "spans": [ + { + "bbox": [ + 105, + 323, + 506, + 336 + ], + "score": 1.0, + "content": "All demonstrations in our experiments are provided via human teleoperation and we collected 100", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 334, + 254, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 254, + 347 + ], + "score": 1.0, + "content": "demonstrations for each experiment.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 301, + 507, + 347 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 352, + 506, + 396 + ], + "lines": [ + { + "bbox": [ + 106, + 352, + 506, + 364 + ], + "spans": [ + { + "bbox": [ + 106, + 352, + 506, + 364 + ], + "score": 1.0, + "content": "Jaco: When using the Jaco arm, we use joint velocity control (9DOF) where we control all 6 joints of", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 363, + 506, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 363, + 506, + 375 + ], + "score": 1.0, + "content": "arm and all 3 joints of the hand. The simulation is run with a numerical time step of 10 milliseconds,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 374, + 506, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 506, + 387 + ], + "score": 1.0, + "content": "integrating 5 steps, to get a control frequency of 20HZ. The agent uses a frontal camera of size", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 384, + 501, + 397 + ], + "spans": [ + { + "bbox": [ + 106, + 385, + 140, + 395 + ], + "score": 0.89, + "content": "6 4 \\times 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 384, + 501, + 397 + ], + "score": 1.0, + "content": "(see Figure 10(a)). For a full list of observations the agent sees, please refer to Table 2(a).", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 352, + 506, + 397 + ] + }, + { + "type": "image", + "bbox": [ + 126, + 405, + 480, + 526 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 126, + 405, + 480, + 526 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 126, + 405, + 480, + 526 + ], + "spans": [ + { + "bbox": [ + 126, + 405, + 480, + 526 + ], + "score": 0.973, + "type": "image", + "image_path": "b6bc13e4b98119453319a74daf7dde365754b163a2a6e1e98dd817c38debb41d.jpg" + } + ] + } + ], + "index": 19, + "virtual_lines": [ + { + "bbox": [ + 126, + 405, + 480, + 445.3333333333333 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 126, + 445.3333333333333, + 480, + 485.66666666666663 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 126, + 485.66666666666663, + 480, + 526.0 + ], + "spans": [], + "index": 20 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 196, + 538, + 414, + 550 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 194, + 536, + 416, + 552 + ], + "spans": [ + { + "bbox": [ + 194, + 536, + 416, + 552 + ], + "score": 1.0, + "content": "Figure 10: Illustration of the pixels inputs to the agent.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + } + ], + "index": 20.0 + }, + { + "type": "text", + "bbox": [ + 106, + 559, + 505, + 626 + ], + "lines": [ + { + "bbox": [ + 106, + 560, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 106, + 560, + 505, + 572 + ], + "score": 1.0, + "content": "Sawyer: When using the Sawyer arm, we use Cartesian velocity control (6DOF) for the robot arm", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 570, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 505, + 583 + ], + "score": 1.0, + "content": "and add one additional action for the gripper resulting in 7 degrees of freedom. The simulation is", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 581, + 506, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 506, + 595 + ], + "score": 1.0, + "content": "run with a numerical time step of 10 milliseconds, integrating 10 steps, to get a control frequency", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 592, + 506, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 322, + 605 + ], + "score": 1.0, + "content": "of 10HZ. The agent uses two frontal cameras of size", + "type": "text" + }, + { + "bbox": [ + 323, + 593, + 357, + 603 + ], + "score": 0.93, + "content": "6 4 \\times 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 592, + 506, + 605 + ], + "score": 1.0, + "content": "situated on the left and right side of", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 262, + 617 + ], + "score": 1.0, + "content": "the robot cage respectively (see Figure", + "type": "text" + }, + { + "bbox": [ + 262, + 604, + 295, + 615 + ], + "score": 0.68, + "content": "1 0 ( \\mathrm { b } , \\mathrm { c } ) ,", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 604, + 505, + 617 + ], + "score": 1.0, + "content": "). For a full list of observations the agent sees, please", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 615, + 184, + 627 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 184, + 627 + ], + "score": 1.0, + "content": "refer to Table 2(b).", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24.5, + "bbox_fs": [ + 105, + 560, + 506, + 627 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 631, + 504, + 665 + ], + "lines": [ + { + "bbox": [ + 105, + 631, + 506, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 631, + 506, + 644 + ], + "score": 1.0, + "content": "For all environments considered in this paper, we provide sparse rewards (i.e. if task is accomplished,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 643, + 505, + 655 + ], + "spans": [ + { + "bbox": [ + 106, + 643, + 505, + 655 + ], + "score": 1.0, + "content": "the reward is 1 and 0 otherwise). In experiments regards our proposed methods, rewards are only", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 654, + 343, + 666 + ], + "spans": [ + { + "bbox": [ + 106, + 654, + 343, + 666 + ], + "score": 1.0, + "content": "used for evaluation purposes and not for training the agent.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29, + "bbox_fs": [ + 105, + 631, + 506, + 666 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 104, + 106, + 282, + 223 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 184, + 99, + 213, + 108 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 182, + 96, + 215, + 110 + ], + "spans": [ + { + "bbox": [ + 182, + 96, + 215, + 110 + ], + "score": 1.0, + "content": "a) Jaco", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "table_body", + "bbox": [ + 104, + 106, + 282, + 223 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 106, + 282, + 223 + ], + "spans": [ + { + "bbox": [ + 104, + 106, + 282, + 223 + ], + "score": 0.961, + "html": "
Feature NameDimensions
frontal camera base force and torque sensors64×64×3 6
arm joints position6
arm joints velocity6
wrist force and torque sensors6
hand finger joints position3
hand finger joints velocity
hand fingertip sensors3
3
grip site position3
pinch site position3
", + "type": "table", + "image_path": "07b4e70c00c60a1551189151f9ee412f3336bc9f65211675aee4c92bca3c9287.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 104, + 106, + 282, + 119.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 104, + 119.0, + 282, + 132.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 104, + 132.0, + 282, + 145.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 104, + 145.0, + 282, + 158.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 104, + 158.0, + 282, + 171.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 104, + 171.0, + 282, + 184.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 104, + 184.0, + 282, + 197.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 104, + 197.0, + 282, + 210.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 104, + 210.0, + 282, + 223.0 + ], + "spans": [], + "index": 10 + } + ] + } + ], + "index": 3.5 + }, + { + "type": "table", + "bbox": [ + 294, + 100, + 500, + 233 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 229, + 90, + 381, + 100 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 228, + 88, + 383, + 102 + ], + "spans": [ + { + "bbox": [ + 228, + 88, + 383, + 102 + ], + "score": 1.0, + "content": "Table 2: Observation and dimensions.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 294, + 100, + 500, + 233 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 294, + 100, + 500, + 233 + ], + "spans": [ + { + "bbox": [ + 294, + 100, + 500, + 233 + ], + "score": 0.957, + "html": "
b) Sawyer
Feature Name frontleft cameraDimensions 64×64×3
front right camera64×64×3
arm joint position7
arm joint velocity7
wrist force sensor3
wrist torque sensor3
hand grasp sensor
1
hand joint position1
tool center point cartesian orientation9
tool center point cartesian position
hand joint velocity3 1
", + "type": "table", + "image_path": "35828ddf5a5369eb1bb42ba00067e3cdf43e97fe28c656aea544c66d4b4046ca.jpg" + } + ] + } + ], + "index": 15.5, + "virtual_lines": [ + { + "bbox": [ + 294, + 100, + 500, + 113.3 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 294, + 113.3, + 500, + 126.6 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 294, + 126.6, + 500, + 139.9 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 294, + 139.9, + 500, + 153.20000000000002 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 294, + 153.20000000000002, + 500, + 166.50000000000003 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 294, + 166.50000000000003, + 500, + 179.80000000000004 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 294, + 179.80000000000004, + 500, + 193.10000000000005 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 294, + 193.10000000000005, + 500, + 206.40000000000006 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 294, + 206.40000000000006, + 500, + 219.70000000000007 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 294, + 219.70000000000007, + 500, + 233.00000000000009 + ], + "spans": [], + "index": 20 + } + ] + } + ], + "index": 7.75 + }, + { + "type": "title", + "bbox": [ + 108, + 255, + 277, + 266 + ], + "lines": [ + { + "bbox": [ + 106, + 255, + 279, + 268 + ], + "spans": [ + { + "bbox": [ + 106, + 255, + 279, + 268 + ], + "score": 1.0, + "content": "A.2 EARLY FRAMES ABLATION STUDY", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 276, + 505, + 309 + ], + "lines": [ + { + "bbox": [ + 105, + 275, + 506, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 392, + 289 + ], + "score": 1.0, + "content": "Here, we vary the number of early frames of each episode used to form", + "type": "text" + }, + { + "bbox": [ + 392, + 276, + 399, + 286 + ], + "score": 0.43, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 275, + 506, + 289 + ], + "score": 1.0, + "content": ". We report that a range of", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 287, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 106, + 287, + 505, + 299 + ], + "score": 1.0, + "content": "values from 1 up to 20 works well across both tasks (Put in box and Stack banana), with performance", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 298, + 362, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 362, + 311 + ], + "score": 1.0, + "content": "gradually degrading as the value increased beyond 20 (Fig. 11).", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23 + }, + { + "type": "image", + "bbox": [ + 125, + 322, + 484, + 429 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 125, + 322, + 484, + 429 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 125, + 322, + 484, + 429 + ], + "spans": [ + { + "bbox": [ + 125, + 322, + 484, + 429 + ], + "score": 0.969, + "type": "image", + "image_path": "62c162c76431293f01240e50adc3fc2894bfed770d528775da6f48cfa37dd471.jpg" + } + ] + } + ], + "index": 26, + "virtual_lines": [ + { + "bbox": [ + 125, + 322, + 484, + 357.6666666666667 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 125, + 357.6666666666667, + 484, + 393.33333333333337 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 125, + 393.33333333333337, + 484, + 429.00000000000006 + ], + "spans": [], + "index": 27 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 104, + 430, + 501, + 442 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 428, + 502, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 490, + 443 + ], + "score": 1.0, + "content": "Figure 11: TRAIL performance, varying the number of first frames in each episode used to form", + "type": "text" + }, + { + "bbox": [ + 490, + 430, + 498, + 440 + ], + "score": 0.61, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 498, + 428, + 502, + 443 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + } + ], + "index": 27.0 + }, + { + "type": "title", + "bbox": [ + 108, + 461, + 234, + 473 + ], + "lines": [ + { + "bbox": [ + 105, + 459, + 236, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 236, + 475 + ], + "score": 1.0, + "content": "A.3 TRAIL-0 WITH random", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 482, + 505, + 538 + ], + "lines": [ + { + "bbox": [ + 105, + 482, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 506, + 496 + ], + "score": 1.0, + "content": "We found out and mentioned in the subsection 5.1 that random benefits from TRAIL-0. Unfortunately,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 494, + 505, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 505, + 506 + ], + "score": 1.0, + "content": "it is still prone to overfitting and hence, worse than our full method – TRAIL. We present random", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 505, + 505, + 517 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 113, + 515 + ], + "score": 0.59, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 505, + 440, + 517 + ], + "score": 1.0, + "content": "TRAIL-0 accompanied with our methods in Figure 12. Our TRAIL and random", + "type": "text" + }, + { + "bbox": [ + 440, + 506, + 449, + 515 + ], + "score": 0.73, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 505, + 505, + 517 + ], + "score": 1.0, + "content": "TRAIL-0 are", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 516, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 106, + 516, + 505, + 528 + ], + "score": 1.0, + "content": "the only methods exceeding BC performance on lift distracted. However, TRAIL performance is", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 526, + 363, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 363, + 540 + ], + "score": 1.0, + "content": "clearly better (obtains higher rewards and never gets overfitted).", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32 + }, + { + "type": "image", + "bbox": [ + 113, + 549, + 492, + 635 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 113, + 549, + 492, + 635 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 113, + 549, + 492, + 635 + ], + "spans": [ + { + "bbox": [ + 113, + 549, + 492, + 635 + ], + "score": 0.965, + "type": "image", + "image_path": "ed344e1142f29ef99b9a64add4b50040c0bf4ab9992f0071804687203c06a46a.jpg" + } + ] + } + ], + "index": 36, + "virtual_lines": [ + { + "bbox": [ + 113, + 549, + 492, + 577.6666666666666 + ], + "spans": [], + "index": 35 + }, + { + "bbox": [ + 113, + 577.6666666666666, + 492, + 606.3333333333333 + ], + "spans": [], + "index": 36 + }, + { + "bbox": [ + 113, + 606.3333333333333, + 492, + 634.9999999999999 + ], + "spans": [], + "index": 37 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 158, + 636, + 451, + 646 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 156, + 634, + 451, + 647 + ], + "spans": [ + { + "bbox": [ + 156, + 634, + 451, + 647 + ], + "score": 1.0, + "content": "Figure 12: Results for lift alone, lift distracted, and lift distracted seeded.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + } + ], + "index": 37.0 + }, + { + "type": "title", + "bbox": [ + 108, + 667, + 257, + 678 + ], + "lines": [ + { + "bbox": [ + 106, + 667, + 258, + 679 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 258, + 679 + ], + "score": 1.0, + "content": "A.4 FIXED TERMINATION POLICY", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 506, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 507, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 507, + 700 + ], + "score": 1.0, + "content": "As mentioned in the subsection 5.2, the most basic early termination policy – fixed step termination –", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "may be very effective if tuned. Since the tuning may be expensive in practice, we recommend using", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "adaptive early stopping (TRAIL-0). However, for the sake of completeness we provide results for", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "score": 1.0, + "content": "fixed step termination policy depending on the hyperparameter tuned. The results for stack task are", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 41.5 + } + ], + "page_idx": 12, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 104, + 106, + 282, + 223 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 184, + 99, + 213, + 108 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 182, + 96, + 215, + 110 + ], + "spans": [ + { + "bbox": [ + 182, + 96, + 215, + 110 + ], + "score": 1.0, + "content": "a) Jaco", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "table_body", + "bbox": [ + 104, + 106, + 282, + 223 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 106, + 282, + 223 + ], + "spans": [ + { + "bbox": [ + 104, + 106, + 282, + 223 + ], + "score": 0.961, + "html": "
Feature NameDimensions
frontal camera base force and torque sensors64×64×3 6
arm joints position6
arm joints velocity6
wrist force and torque sensors6
hand finger joints position3
hand finger joints velocity
hand fingertip sensors3
3
grip site position3
pinch site position3
", + "type": "table", + "image_path": "07b4e70c00c60a1551189151f9ee412f3336bc9f65211675aee4c92bca3c9287.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 104, + 106, + 282, + 119.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 104, + 119.0, + 282, + 132.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 104, + 132.0, + 282, + 145.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 104, + 145.0, + 282, + 158.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 104, + 158.0, + 282, + 171.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 104, + 171.0, + 282, + 184.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 104, + 184.0, + 282, + 197.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 104, + 197.0, + 282, + 210.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 104, + 210.0, + 282, + 223.0 + ], + "spans": [], + "index": 10 + } + ] + } + ], + "index": 3.5 + }, + { + "type": "table", + "bbox": [ + 294, + 100, + 500, + 233 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 229, + 90, + 381, + 100 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 228, + 88, + 383, + 102 + ], + "spans": [ + { + "bbox": [ + 228, + 88, + 383, + 102 + ], + "score": 1.0, + "content": "Table 2: Observation and dimensions.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 294, + 100, + 500, + 233 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 294, + 100, + 500, + 233 + ], + "spans": [ + { + "bbox": [ + 294, + 100, + 500, + 233 + ], + "score": 0.957, + "html": "
b) Sawyer
Feature Name frontleft cameraDimensions 64×64×3
front right camera64×64×3
arm joint position7
arm joint velocity7
wrist force sensor3
wrist torque sensor3
hand grasp sensor
1
hand joint position1
tool center point cartesian orientation9
tool center point cartesian position
hand joint velocity3 1
", + "type": "table", + "image_path": "35828ddf5a5369eb1bb42ba00067e3cdf43e97fe28c656aea544c66d4b4046ca.jpg" + } + ] + } + ], + "index": 15.5, + "virtual_lines": [ + { + "bbox": [ + 294, + 100, + 500, + 113.3 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 294, + 113.3, + 500, + 126.6 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 294, + 126.6, + 500, + 139.9 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 294, + 139.9, + 500, + 153.20000000000002 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 294, + 153.20000000000002, + 500, + 166.50000000000003 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 294, + 166.50000000000003, + 500, + 179.80000000000004 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 294, + 179.80000000000004, + 500, + 193.10000000000005 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 294, + 193.10000000000005, + 500, + 206.40000000000006 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 294, + 206.40000000000006, + 500, + 219.70000000000007 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 294, + 219.70000000000007, + 500, + 233.00000000000009 + ], + "spans": [], + "index": 20 + } + ] + } + ], + "index": 7.75 + }, + { + "type": "title", + "bbox": [ + 108, + 255, + 277, + 266 + ], + "lines": [ + { + "bbox": [ + 106, + 255, + 279, + 268 + ], + "spans": [ + { + "bbox": [ + 106, + 255, + 279, + 268 + ], + "score": 1.0, + "content": "A.2 EARLY FRAMES ABLATION STUDY", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 276, + 505, + 309 + ], + "lines": [ + { + "bbox": [ + 105, + 275, + 506, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 392, + 289 + ], + "score": 1.0, + "content": "Here, we vary the number of early frames of each episode used to form", + "type": "text" + }, + { + "bbox": [ + 392, + 276, + 399, + 286 + ], + "score": 0.43, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 275, + 506, + 289 + ], + "score": 1.0, + "content": ". We report that a range of", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 287, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 106, + 287, + 505, + 299 + ], + "score": 1.0, + "content": "values from 1 up to 20 works well across both tasks (Put in box and Stack banana), with performance", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 298, + 362, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 362, + 311 + ], + "score": 1.0, + "content": "gradually degrading as the value increased beyond 20 (Fig. 11).", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 275, + 506, + 311 + ] + }, + { + "type": "image", + "bbox": [ + 125, + 322, + 484, + 429 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 125, + 322, + 484, + 429 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 125, + 322, + 484, + 429 + ], + "spans": [ + { + "bbox": [ + 125, + 322, + 484, + 429 + ], + "score": 0.969, + "type": "image", + "image_path": "62c162c76431293f01240e50adc3fc2894bfed770d528775da6f48cfa37dd471.jpg" + } + ] + } + ], + "index": 26, + "virtual_lines": [ + { + "bbox": [ + 125, + 322, + 484, + 357.6666666666667 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 125, + 357.6666666666667, + 484, + 393.33333333333337 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 125, + 393.33333333333337, + 484, + 429.00000000000006 + ], + "spans": [], + "index": 27 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 104, + 430, + 501, + 442 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 428, + 502, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 490, + 443 + ], + "score": 1.0, + "content": "Figure 11: TRAIL performance, varying the number of first frames in each episode used to form", + "type": "text" + }, + { + "bbox": [ + 490, + 430, + 498, + 440 + ], + "score": 0.61, + "content": "\\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 498, + 428, + 502, + 443 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + } + ], + "index": 27.0 + }, + { + "type": "title", + "bbox": [ + 108, + 461, + 234, + 473 + ], + "lines": [ + { + "bbox": [ + 105, + 459, + 236, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 236, + 475 + ], + "score": 1.0, + "content": "A.3 TRAIL-0 WITH random", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 482, + 505, + 538 + ], + "lines": [ + { + "bbox": [ + 105, + 482, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 506, + 496 + ], + "score": 1.0, + "content": "We found out and mentioned in the subsection 5.1 that random benefits from TRAIL-0. Unfortunately,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 494, + 505, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 505, + 506 + ], + "score": 1.0, + "content": "it is still prone to overfitting and hence, worse than our full method – TRAIL. We present random", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 505, + 505, + 517 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 113, + 515 + ], + "score": 0.59, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 505, + 440, + 517 + ], + "score": 1.0, + "content": "TRAIL-0 accompanied with our methods in Figure 12. Our TRAIL and random", + "type": "text" + }, + { + "bbox": [ + 440, + 506, + 449, + 515 + ], + "score": 0.73, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 505, + 505, + 517 + ], + "score": 1.0, + "content": "TRAIL-0 are", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 516, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 106, + 516, + 505, + 528 + ], + "score": 1.0, + "content": "the only methods exceeding BC performance on lift distracted. However, TRAIL performance is", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 526, + 363, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 363, + 540 + ], + "score": 1.0, + "content": "clearly better (obtains higher rewards and never gets overfitted).", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32, + "bbox_fs": [ + 105, + 482, + 506, + 540 + ] + }, + { + "type": "image", + "bbox": [ + 113, + 549, + 492, + 635 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 113, + 549, + 492, + 635 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 113, + 549, + 492, + 635 + ], + "spans": [ + { + "bbox": [ + 113, + 549, + 492, + 635 + ], + "score": 0.965, + "type": "image", + "image_path": "ed344e1142f29ef99b9a64add4b50040c0bf4ab9992f0071804687203c06a46a.jpg" + } + ] + } + ], + "index": 36, + "virtual_lines": [ + { + "bbox": [ + 113, + 549, + 492, + 577.6666666666666 + ], + "spans": [], + "index": 35 + }, + { + "bbox": [ + 113, + 577.6666666666666, + 492, + 606.3333333333333 + ], + "spans": [], + "index": 36 + }, + { + "bbox": [ + 113, + 606.3333333333333, + 492, + 634.9999999999999 + ], + "spans": [], + "index": 37 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 158, + 636, + 451, + 646 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 156, + 634, + 451, + 647 + ], + "spans": [ + { + "bbox": [ + 156, + 634, + 451, + 647 + ], + "score": 1.0, + "content": "Figure 12: Results for lift alone, lift distracted, and lift distracted seeded.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + } + ], + "index": 37.0 + }, + { + "type": "title", + "bbox": [ + 108, + 667, + 257, + 678 + ], + "lines": [ + { + "bbox": [ + 106, + 667, + 258, + 679 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 258, + 679 + ], + "score": 1.0, + "content": "A.4 FIXED TERMINATION POLICY", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 506, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 507, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 507, + 700 + ], + "score": 1.0, + "content": "As mentioned in the subsection 5.2, the most basic early termination policy – fixed step termination –", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "may be very effective if tuned. Since the tuning may be expensive in practice, we recommend using", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "adaptive early stopping (TRAIL-0). However, for the sake of completeness we provide results for", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "score": 1.0, + "content": "fixed step termination policy depending on the hyperparameter tuned. The results for stack task are", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "presented in Figure 13. The Jaco work space is considered here because Sawyer requires TRAIL to", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "obtain high rewards. As can be inferred from the figure, the performance is very sensitive to the fixed", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 443, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 443, + 116 + ], + "score": 1.0, + "content": "step hyperparameter. We refer to subsection 5.2 for more comments on all methods.", + "type": "text", + "cross_page": true + } + ], + "index": 2 + } + ], + "index": 41.5, + "bbox_fs": [ + 105, + 687, + 507, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 505, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "presented in Figure 13. The Jaco work space is considered here because Sawyer requires TRAIL to", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "obtain high rewards. As can be inferred from the figure, the performance is very sensitive to the fixed", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 443, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 443, + 116 + ], + "score": 1.0, + "content": "step hyperparameter. We refer to subsection 5.2 for more comments on all methods.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "image", + "bbox": [ + 190, + 127, + 414, + 245 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 190, + 127, + 414, + 245 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 190, + 127, + 414, + 245 + ], + "spans": [ + { + "bbox": [ + 190, + 127, + 414, + 245 + ], + "score": 0.96, + "type": "image", + "image_path": "6ce8e8947b35ee83aff9d74c4c2c443c36dcd3ab4361b7b7f06e4556241f9585.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 190, + 127, + 414, + 140.11111111111111 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 190, + 140.11111111111111, + 414, + 153.22222222222223 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 190, + 153.22222222222223, + 414, + 166.33333333333334 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 190, + 166.33333333333334, + 414, + 179.44444444444446 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 190, + 179.44444444444446, + 414, + 192.55555555555557 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 190, + 192.55555555555557, + 414, + 205.66666666666669 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 190, + 205.66666666666669, + 414, + 218.7777777777778 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 190, + 218.7777777777778, + 414, + 231.8888888888889 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 190, + 231.8888888888889, + 414, + 245.00000000000003 + ], + "spans": [], + "index": 11 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 258, + 505, + 291 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 257, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 106, + 257, + 505, + 271 + ], + "score": 1.0, + "content": "Figure 13: Results for stack in Jaco work space. Fixed step termination policy can be very effective", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 268, + 505, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 268, + 505, + 281 + ], + "score": 1.0, + "content": "but the final performance is very sensitive to the hyperparameter. TRAIL-0 does not need tuning nor", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 280, + 244, + 291 + ], + "spans": [ + { + "bbox": [ + 105, + 280, + 244, + 291 + ], + "score": 1.0, + "content": "access to the environment reward.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13 + } + ], + "index": 10.0 + }, + { + "type": "title", + "bbox": [ + 108, + 308, + 229, + 319 + ], + "lines": [ + { + "bbox": [ + 106, + 307, + 230, + 321 + ], + "spans": [ + { + "bbox": [ + 106, + 307, + 230, + 321 + ], + "score": 1.0, + "content": "A.5 DATA AUGMENTATION", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 106, + 328, + 504, + 351 + ], + "lines": [ + { + "bbox": [ + 106, + 328, + 505, + 341 + ], + "spans": [ + { + "bbox": [ + 106, + 328, + 505, + 341 + ], + "score": 1.0, + "content": "An extra set of experiments on lift alone and lift distracted tasks (described in subsection 5.1) has", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 340, + 342, + 352 + ], + "spans": [ + { + "bbox": [ + 106, + 340, + 342, + 352 + ], + "score": 1.0, + "content": "been performed to show importance of data augmentation.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16.5 + }, + { + "type": "text", + "bbox": [ + 107, + 357, + 506, + 390 + ], + "lines": [ + { + "bbox": [ + 105, + 356, + 506, + 370 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 506, + 370 + ], + "score": 1.0, + "content": "Because in the subsection 5.2 only the peak performance is presented (Table 5.2), we present here the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 367, + 505, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 505, + 380 + ], + "score": 1.0, + "content": "full curves in Figure 14. The results shows that data augmentation is necessary to obtain high rewards", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 378, + 506, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 506, + 391 + ], + "score": 1.0, + "content": "in lift distracted. For easier lift alone, TRAIL-0 with data augmentation perform at par with TRAIL.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19 + }, + { + "type": "image", + "bbox": [ + 111, + 401, + 501, + 519 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 111, + 401, + 501, + 519 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 111, + 401, + 501, + 519 + ], + "spans": [ + { + "bbox": [ + 111, + 401, + 501, + 519 + ], + "score": 0.966, + "type": "image", + "image_path": "bb24dedec05c204244af33e7fd3602ca1d47b8b427d2224cef1cd3839e7e72d0.jpg" + } + ] + } + ], + "index": 22, + "virtual_lines": [ + { + "bbox": [ + 111, + 401, + 501, + 440.3333333333333 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 111, + 440.3333333333333, + 501, + 479.66666666666663 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 111, + 479.66666666666663, + 501, + 519.0 + ], + "spans": [], + "index": 23 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 532, + 506, + 565 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 531, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 506, + 545 + ], + "score": 1.0, + "content": "Figure 14: Results for lift alone and lift distracted in Sawyer work space. TRAIL and TRAIL-0 are", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 543, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 106, + 543, + 505, + 555 + ], + "score": 1.0, + "content": "by default with data augmentation. Additional results for these methods without data augmentation", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 555, + 257, + 567 + ], + "spans": [ + { + "bbox": [ + 106, + 555, + 257, + 567 + ], + "score": 1.0, + "content": "are presented to show its importance.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25 + } + ], + "index": 23.5 + }, + { + "type": "title", + "bbox": [ + 108, + 584, + 160, + 595 + ], + "lines": [ + { + "bbox": [ + 105, + 582, + 162, + 597 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 162, + 597 + ], + "score": 1.0, + "content": "A.6 D4PG", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 106, + 604, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 604, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 506, + 617 + ], + "score": 1.0, + "content": "We use D4PG (Barth-Maron et al., 2018) as our main training algorithm. Briefly, D4PG is a distributed", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 615, + 506, + 629 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 506, + 629 + ], + "score": 1.0, + "content": "off-policy reinforcement learning algorithm for continuous control problems. In a nutshell, D4PG", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 627, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 506, + 640 + ], + "score": 1.0, + "content": "uses Q-learning for policy evaluation and Deterministic Policy Gradients (DPG) (Silver et al., 2014)", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 637, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 506, + 651 + ], + "score": 1.0, + "content": "for policy optimization. An important characteristic of D4PG is that it maintains a replay memory", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 107, + 648, + 505, + 663 + ], + "spans": [ + { + "bbox": [ + 107, + 650, + 120, + 659 + ], + "score": 0.79, + "content": "\\mathcal { M }", + "type": "inline_equation" + }, + { + "bbox": [ + 120, + 648, + 505, + 663 + ], + "score": 1.0, + "content": "(possibility prioritized (Horgan et al., 2018)) that stores SARS tuples which allows for off-policy", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 659, + 506, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 506, + 673 + ], + "score": 1.0, + "content": "learning. D4PG also adopts target networks for increased training stability. In addition to these", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 671, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 505, + 684 + ], + "score": 1.0, + "content": "principles, D4PG utilized distributed training, distributional value functions, and multi-step returns to", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 682, + 506, + 694 + ], + "spans": [ + { + "bbox": [ + 106, + 682, + 506, + 694 + ], + "score": 1.0, + "content": "further increase efficiency and stability. In this section, we explain the different ingredients of D4PG.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 31.5 + }, + { + "type": "text", + "bbox": [ + 108, + 698, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 272, + 712 + ], + "score": 1.0, + "content": "D4PG maintains an online value network", + "type": "text" + }, + { + "bbox": [ + 272, + 700, + 311, + 711 + ], + "score": 0.92, + "content": "Q ( s , a | \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 698, + 429, + 712 + ], + "score": 1.0, + "content": "and an online policy network", + "type": "text" + }, + { + "bbox": [ + 430, + 699, + 457, + 711 + ], + "score": 0.92, + "content": "\\pi ( s | \\phi )", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 698, + 505, + 712 + ], + "score": 1.0, + "content": ". The target", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "networks are of the same structures as the value and policy network, but are parameterized by different", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 720, + 507, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 152, + 732 + ], + "score": 1.0, + "content": "parameters", + "type": "text" + }, + { + "bbox": [ + 152, + 721, + 161, + 730 + ], + "score": 0.85, + "content": "\\theta ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 161, + 720, + 178, + 732 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 179, + 721, + 189, + 732 + ], + "score": 0.88, + "content": "\\phi ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 720, + 507, + 732 + ], + "score": 1.0, + "content": "which are periodically updated to the current parameters of the online networks.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37 + } + ], + "page_idx": 13, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 505, + 116 + ], + "lines": [], + "index": 1, + "bbox_fs": [ + 105, + 82, + 505, + 116 + ], + "lines_deleted": true + }, + { + "type": "image", + "bbox": [ + 190, + 127, + 414, + 245 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 190, + 127, + 414, + 245 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 190, + 127, + 414, + 245 + ], + "spans": [ + { + "bbox": [ + 190, + 127, + 414, + 245 + ], + "score": 0.96, + "type": "image", + "image_path": "6ce8e8947b35ee83aff9d74c4c2c443c36dcd3ab4361b7b7f06e4556241f9585.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 190, + 127, + 414, + 140.11111111111111 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 190, + 140.11111111111111, + 414, + 153.22222222222223 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 190, + 153.22222222222223, + 414, + 166.33333333333334 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 190, + 166.33333333333334, + 414, + 179.44444444444446 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 190, + 179.44444444444446, + 414, + 192.55555555555557 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 190, + 192.55555555555557, + 414, + 205.66666666666669 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 190, + 205.66666666666669, + 414, + 218.7777777777778 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 190, + 218.7777777777778, + 414, + 231.8888888888889 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 190, + 231.8888888888889, + 414, + 245.00000000000003 + ], + "spans": [], + "index": 11 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 258, + 505, + 291 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 257, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 106, + 257, + 505, + 271 + ], + "score": 1.0, + "content": "Figure 13: Results for stack in Jaco work space. Fixed step termination policy can be very effective", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 268, + 505, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 268, + 505, + 281 + ], + "score": 1.0, + "content": "but the final performance is very sensitive to the hyperparameter. TRAIL-0 does not need tuning nor", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 280, + 244, + 291 + ], + "spans": [ + { + "bbox": [ + 105, + 280, + 244, + 291 + ], + "score": 1.0, + "content": "access to the environment reward.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13 + } + ], + "index": 10.0 + }, + { + "type": "title", + "bbox": [ + 108, + 308, + 229, + 319 + ], + "lines": [ + { + "bbox": [ + 106, + 307, + 230, + 321 + ], + "spans": [ + { + "bbox": [ + 106, + 307, + 230, + 321 + ], + "score": 1.0, + "content": "A.5 DATA AUGMENTATION", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 106, + 328, + 504, + 351 + ], + "lines": [ + { + "bbox": [ + 106, + 328, + 505, + 341 + ], + "spans": [ + { + "bbox": [ + 106, + 328, + 505, + 341 + ], + "score": 1.0, + "content": "An extra set of experiments on lift alone and lift distracted tasks (described in subsection 5.1) has", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 340, + 342, + 352 + ], + "spans": [ + { + "bbox": [ + 106, + 340, + 342, + 352 + ], + "score": 1.0, + "content": "been performed to show importance of data augmentation.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16.5, + "bbox_fs": [ + 106, + 328, + 505, + 352 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 357, + 506, + 390 + ], + "lines": [ + { + "bbox": [ + 105, + 356, + 506, + 370 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 506, + 370 + ], + "score": 1.0, + "content": "Because in the subsection 5.2 only the peak performance is presented (Table 5.2), we present here the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 367, + 505, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 505, + 380 + ], + "score": 1.0, + "content": "full curves in Figure 14. The results shows that data augmentation is necessary to obtain high rewards", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 378, + 506, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 506, + 391 + ], + "score": 1.0, + "content": "in lift distracted. For easier lift alone, TRAIL-0 with data augmentation perform at par with TRAIL.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19, + "bbox_fs": [ + 105, + 356, + 506, + 391 + ] + }, + { + "type": "image", + "bbox": [ + 111, + 401, + 501, + 519 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 111, + 401, + 501, + 519 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 111, + 401, + 501, + 519 + ], + "spans": [ + { + "bbox": [ + 111, + 401, + 501, + 519 + ], + "score": 0.966, + "type": "image", + "image_path": "bb24dedec05c204244af33e7fd3602ca1d47b8b427d2224cef1cd3839e7e72d0.jpg" + } + ] + } + ], + "index": 22, + "virtual_lines": [ + { + "bbox": [ + 111, + 401, + 501, + 440.3333333333333 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 111, + 440.3333333333333, + 501, + 479.66666666666663 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 111, + 479.66666666666663, + 501, + 519.0 + ], + "spans": [], + "index": 23 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 532, + 506, + 565 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 531, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 506, + 545 + ], + "score": 1.0, + "content": "Figure 14: Results for lift alone and lift distracted in Sawyer work space. TRAIL and TRAIL-0 are", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 543, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 106, + 543, + 505, + 555 + ], + "score": 1.0, + "content": "by default with data augmentation. Additional results for these methods without data augmentation", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 555, + 257, + 567 + ], + "spans": [ + { + "bbox": [ + 106, + 555, + 257, + 567 + ], + "score": 1.0, + "content": "are presented to show its importance.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25 + } + ], + "index": 23.5 + }, + { + "type": "title", + "bbox": [ + 108, + 584, + 160, + 595 + ], + "lines": [ + { + "bbox": [ + 105, + 582, + 162, + 597 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 162, + 597 + ], + "score": 1.0, + "content": "A.6 D4PG", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 106, + 604, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 604, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 506, + 617 + ], + "score": 1.0, + "content": "We use D4PG (Barth-Maron et al., 2018) as our main training algorithm. Briefly, D4PG is a distributed", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 615, + 506, + 629 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 506, + 629 + ], + "score": 1.0, + "content": "off-policy reinforcement learning algorithm for continuous control problems. In a nutshell, D4PG", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 627, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 506, + 640 + ], + "score": 1.0, + "content": "uses Q-learning for policy evaluation and Deterministic Policy Gradients (DPG) (Silver et al., 2014)", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 637, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 506, + 651 + ], + "score": 1.0, + "content": "for policy optimization. An important characteristic of D4PG is that it maintains a replay memory", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 107, + 648, + 505, + 663 + ], + "spans": [ + { + "bbox": [ + 107, + 650, + 120, + 659 + ], + "score": 0.79, + "content": "\\mathcal { M }", + "type": "inline_equation" + }, + { + "bbox": [ + 120, + 648, + 505, + 663 + ], + "score": 1.0, + "content": "(possibility prioritized (Horgan et al., 2018)) that stores SARS tuples which allows for off-policy", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 659, + 506, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 506, + 673 + ], + "score": 1.0, + "content": "learning. D4PG also adopts target networks for increased training stability. In addition to these", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 671, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 505, + 684 + ], + "score": 1.0, + "content": "principles, D4PG utilized distributed training, distributional value functions, and multi-step returns to", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 682, + 506, + 694 + ], + "spans": [ + { + "bbox": [ + 106, + 682, + 506, + 694 + ], + "score": 1.0, + "content": "further increase efficiency and stability. In this section, we explain the different ingredients of D4PG.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 31.5, + "bbox_fs": [ + 105, + 604, + 506, + 694 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 698, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 272, + 712 + ], + "score": 1.0, + "content": "D4PG maintains an online value network", + "type": "text" + }, + { + "bbox": [ + 272, + 700, + 311, + 711 + ], + "score": 0.92, + "content": "Q ( s , a | \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 698, + 429, + 712 + ], + "score": 1.0, + "content": "and an online policy network", + "type": "text" + }, + { + "bbox": [ + 430, + 699, + 457, + 711 + ], + "score": 0.92, + "content": "\\pi ( s | \\phi )", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 698, + 505, + 712 + ], + "score": 1.0, + "content": ". The target", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "networks are of the same structures as the value and policy network, but are parameterized by different", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 720, + 507, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 152, + 732 + ], + "score": 1.0, + "content": "parameters", + "type": "text" + }, + { + "bbox": [ + 152, + 721, + 161, + 730 + ], + "score": 0.85, + "content": "\\theta ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 161, + 720, + 178, + 732 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 179, + 721, + 189, + 732 + ], + "score": 0.88, + "content": "\\phi ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 720, + 507, + 732 + ], + "score": 1.0, + "content": "which are periodically updated to the current parameters of the online networks.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37, + "bbox_fs": [ + 105, + 698, + 507, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 346, + 95 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 347, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 147, + 96 + ], + "score": 1.0, + "content": "Given the", + "type": "text" + }, + { + "bbox": [ + 147, + 83, + 157, + 94 + ], + "score": 0.85, + "content": "Q", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 81, + 347, + 96 + ], + "score": 1.0, + "content": "function, we can update the policy using DPG:", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "interline_equation", + "bbox": [ + 226, + 104, + 385, + 119 + ], + "lines": [ + { + "bbox": [ + 226, + 104, + 385, + 119 + ], + "spans": [ + { + "bbox": [ + 226, + 104, + 385, + 119 + ], + "score": 0.92, + "content": "\\mathcal { I } ( \\phi ) = \\mathbb { E } _ { s _ { t } \\sim \\mathcal { M } } \\left[ \\nabla _ { \\phi } Q ( s _ { t } , \\pi ( s _ { t } | \\phi ) | \\theta ) \\right] .", + "type": "interline_equation", + "image_path": "d9a9a466471a108f418f609eafa9bc0cc7366850e41f8714acb68e7b0816f19e.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 226, + 104, + 385, + 119 + ], + "spans": [], + "index": 1 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 135, + 505, + 185 + ], + "lines": [ + { + "bbox": [ + 105, + 133, + 506, + 148 + ], + "spans": [ + { + "bbox": [ + 105, + 133, + 217, + 148 + ], + "score": 1.0, + "content": "Instead of using a scalar", + "type": "text" + }, + { + "bbox": [ + 217, + 136, + 227, + 147 + ], + "score": 0.8, + "content": "Q", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 133, + 506, + 148 + ], + "score": 1.0, + "content": "function, D4PG adopts a distributional value function such that", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 145, + 505, + 160 + ], + "spans": [ + { + "bbox": [ + 106, + 146, + 226, + 159 + ], + "score": 0.9, + "content": "Q ( s _ { t } , a | \\theta ) ~ = ~ \\bar { \\mathbb { E } } \\big [ Z ( s _ { t } , a | \\theta ) \\big ]", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 145, + 260, + 160 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 260, + 147, + 269, + 157 + ], + "score": 0.82, + "content": "Z", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 145, + 410, + 160 + ], + "score": 1.0, + "content": "is a random variable such that", + "type": "text" + }, + { + "bbox": [ + 410, + 147, + 449, + 158 + ], + "score": 0.91, + "content": "Z ~ = ~ z _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 145, + 479, + 160 + ], + "score": 1.0, + "content": "w.p.", + "type": "text" + }, + { + "bbox": [ + 479, + 148, + 505, + 158 + ], + "score": 0.81, + "content": "\\qquad p _ { i } \\propto", + "type": "inline_equation" + } + ], + "index": 3 + }, + { + "bbox": [ + 107, + 158, + 505, + 172 + ], + "spans": [ + { + "bbox": [ + 107, + 159, + 169, + 171 + ], + "score": 0.89, + "content": "\\exp ( \\omega ( s _ { t } , a | \\theta ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 158, + 195, + 172 + ], + "score": 1.0, + "content": ". The", + "type": "text" + }, + { + "bbox": [ + 196, + 160, + 205, + 169 + ], + "score": 0.82, + "content": "z _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 158, + 247, + 172 + ], + "score": 1.0, + "content": "’s take on", + "type": "text" + }, + { + "bbox": [ + 247, + 159, + 270, + 169 + ], + "score": 0.89, + "content": "V _ { b i n s }", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 158, + 463, + 172 + ], + "score": 1.0, + "content": "discrete values that ranges uniformly between", + "type": "text" + }, + { + "bbox": [ + 464, + 159, + 486, + 170 + ], + "score": 0.91, + "content": "V _ { m i n }", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 158, + 505, + 172 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 107, + 166, + 389, + 188 + ], + "spans": [ + { + "bbox": [ + 107, + 171, + 130, + 182 + ], + "score": 0.88, + "content": "V _ { m a x }", + "type": "inline_equation" + }, + { + "bbox": [ + 130, + 166, + 169, + 188 + ], + "score": 1.0, + "content": "such that", + "type": "text" + }, + { + "bbox": [ + 169, + 170, + 274, + 185 + ], + "score": 0.92, + "content": "\\begin{array} { r } { z _ { i } = V _ { m i n } + i \\frac { V _ { m a x } - V _ { m i n } } { V _ { b i n s } } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 274, + 166, + 290, + 188 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 290, + 170, + 384, + 183 + ], + "score": 0.89, + "content": "i \\in \\{ 0 , \\cdots , V _ { b i n s } - 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 384, + 166, + 389, + 188 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 106, + 188, + 505, + 247 + ], + "lines": [ + { + "bbox": [ + 105, + 188, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 282, + 201 + ], + "score": 1.0, + "content": "To construct a bootstrap target, D4PG uses", + "type": "text" + }, + { + "bbox": [ + 282, + 190, + 292, + 199 + ], + "score": 0.32, + "content": "\\mathbf { N } .", + "type": "inline_equation" + }, + { + "bbox": [ + 292, + 188, + 505, + 201 + ], + "score": 1.0, + "content": "-step returns. Given a sampled tuple from the replay", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 199, + 507, + 213 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 147, + 213 + ], + "score": 1.0, + "content": "memory:", + "type": "text" + }, + { + "bbox": [ + 147, + 200, + 295, + 212 + ], + "score": 0.87, + "content": "s _ { t } , a _ { t } , \\{ r _ { t } , r _ { t + 1 } , \\cdot \\cdot \\cdot , r _ { t + N - 1 } \\} , s _ { t + N }", + "type": "inline_equation" + }, + { + "bbox": [ + 296, + 199, + 452, + 213 + ], + "score": 1.0, + "content": ", we construct a new random variable", + "type": "text" + }, + { + "bbox": [ + 452, + 200, + 464, + 210 + ], + "score": 0.87, + "content": "Z ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 199, + 507, + 213 + ], + "score": 1.0, + "content": "such that", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 209, + 507, + 228 + ], + "spans": [ + { + "bbox": [ + 104, + 209, + 184, + 228 + ], + "score": 1.0, + "content": "Z0 = zi + PN−1n=0", + "type": "text" + }, + { + "bbox": [ + 213, + 210, + 236, + 227 + ], + "score": 1.0, + "content": "w.p.", + "type": "text" + }, + { + "bbox": [ + 237, + 213, + 380, + 225 + ], + "score": 0.9, + "content": "p _ { i } \\propto \\exp ( \\omega ( s _ { t + N } , \\pi ( s _ { t + N } | \\phi ^ { \\prime } ) | \\theta ^ { \\prime } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 210, + 418, + 227 + ], + "score": 1.0, + "content": ". Notice,", + "type": "text" + }, + { + "bbox": [ + 419, + 213, + 430, + 223 + ], + "score": 0.86, + "content": "Z ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 430, + 210, + 507, + 227 + ], + "score": 1.0, + "content": "no longer has the", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 223, + 505, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 223, + 325, + 236 + ], + "score": 1.0, + "content": "same support. We therefore adopt the same projection", + "type": "text" + }, + { + "bbox": [ + 325, + 225, + 334, + 234 + ], + "score": 0.79, + "content": "\\Phi", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 223, + 505, + 236 + ], + "score": 1.0, + "content": "employed by Bellemare et al. (2017). The", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 235, + 246, + 247 + ], + "spans": [ + { + "bbox": [ + 106, + 235, + 246, + 247 + ], + "score": 1.0, + "content": "training loss for the value function", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8 + }, + { + "type": "interline_equation", + "bbox": [ + 177, + 257, + 433, + 272 + ], + "lines": [ + { + "bbox": [ + 177, + 257, + 433, + 272 + ], + "spans": [ + { + "bbox": [ + 177, + 257, + 433, + 272 + ], + "score": 0.87, + "content": "\\mathcal { L } ( \\theta ) = \\mathbb { E } _ { s _ { t } , a _ { t } , \\{ r _ { t } , \\cdots , r _ { t + N - 1 } \\} , s _ { t + N } \\sim \\mathcal { M } } \\big [ H \\big ( \\Phi ( Z ^ { \\prime } ) , Z ( s _ { t } , a _ { t } | \\theta ) \\big ) \\big ] ,", + "type": "interline_equation", + "image_path": "4325c14ac5c5caff010358a3b8f4b5186d28590f7cd88b92da06c98b8b3dfb6a.jpg" + } + ] + } + ], + "index": 11, + "virtual_lines": [ + { + "bbox": [ + 177, + 257, + 433, + 272 + ], + "spans": [], + "index": 11 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 282, + 225, + 294 + ], + "lines": [ + { + "bbox": [ + 106, + 280, + 226, + 297 + ], + "spans": [ + { + "bbox": [ + 106, + 280, + 133, + 297 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 283, + 143, + 292 + ], + "score": 0.84, + "content": "H", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 280, + 226, + 297 + ], + "score": 1.0, + "content": "is the cross entropy.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 298, + 506, + 366 + ], + "lines": [ + { + "bbox": [ + 105, + 298, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 505, + 312 + ], + "score": 1.0, + "content": "D4PG is also distributed following Horgan et al. (2018). Since all learning processes only rely on", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 309, + 506, + 322 + ], + "spans": [ + { + "bbox": [ + 106, + 309, + 506, + 322 + ], + "score": 1.0, + "content": "the replay memory, we can easily decouple the ‘actors’ from the ‘learners’. D4PG therefore uses a", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 321, + 506, + 334 + ], + "spans": [ + { + "bbox": [ + 105, + 321, + 506, + 334 + ], + "score": 1.0, + "content": "large number of independent actor processes which act in the environment and write data to a central", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 104, + 331, + 507, + 346 + ], + "spans": [ + { + "bbox": [ + 104, + 331, + 507, + 346 + ], + "score": 1.0, + "content": "replay memory process. The learners could then draw samples from the replay memory for learning.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 342, + 505, + 356 + ], + "spans": [ + { + "bbox": [ + 105, + 342, + 505, + 356 + ], + "score": 1.0, + "content": "The learner also serves as a parameter server to the actors which periodically update their policy", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 354, + 221, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 354, + 221, + 365 + ], + "score": 1.0, + "content": "parameters from the learner.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 107, + 371, + 505, + 405 + ], + "lines": [ + { + "bbox": [ + 105, + 370, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 505, + 384 + ], + "score": 1.0, + "content": "In our experiments, we always have access to expert demonstrations. We, therefore adopt the practice", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 381, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 505, + 394 + ], + "score": 1.0, + "content": "from DQfD and DDPGfD and put the demonstrations into our replay buffers. For more details see", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 393, + 174, + 406 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 174, + 406 + ], + "score": 1.0, + "content": "Algorithms 1, 2.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20 + }, + { + "type": "title", + "bbox": [ + 107, + 423, + 185, + 434 + ], + "lines": [ + { + "bbox": [ + 105, + 422, + 186, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 422, + 186, + 436 + ], + "score": 1.0, + "content": "Algorithm 1 Actor", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 109, + 437, + 380, + 540 + ], + "lines": [ + { + "bbox": [ + 115, + 435, + 148, + 450 + ], + "spans": [ + { + "bbox": [ + 115, + 435, + 148, + 450 + ], + "score": 1.0, + "content": "Given:", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 142, + 450, + 286, + 461 + ], + "spans": [ + { + "bbox": [ + 142, + 450, + 273, + 461 + ], + "score": 1.0, + "content": "• an experience replay memory", + "type": "text" + }, + { + "bbox": [ + 273, + 450, + 286, + 460 + ], + "score": 0.67, + "content": "\\mathcal { M }", + "type": "inline_equation" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 462, + 185, + 475 + ], + "spans": [ + { + "bbox": [ + 115, + 462, + 131, + 475 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 131, + 464, + 169, + 474 + ], + "score": 0.26, + "content": "n _ { e p i s o d e s }", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 462, + 185, + 475 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 126, + 473, + 199, + 484 + ], + "spans": [ + { + "bbox": [ + 126, + 473, + 141, + 484 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 141, + 474, + 165, + 483 + ], + "score": 0.86, + "content": "t = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 473, + 176, + 484 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 176, + 474, + 185, + 483 + ], + "score": 0.69, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 473, + 199, + 484 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 136, + 483, + 314, + 497 + ], + "spans": [ + { + "bbox": [ + 136, + 483, + 266, + 497 + ], + "score": 1.0, + "content": "Sample action from task policy:", + "type": "text" + }, + { + "bbox": [ + 267, + 484, + 314, + 496 + ], + "score": 0.92, + "content": "\\boldsymbol { a } _ { t } \\gets \\pi ( \\boldsymbol { s } _ { t } )", + "type": "inline_equation" + } + ], + "index": 27 + }, + { + "bbox": [ + 136, + 495, + 378, + 507 + ], + "spans": [ + { + "bbox": [ + 136, + 495, + 197, + 507 + ], + "score": 1.0, + "content": "Execute action", + "type": "text" + }, + { + "bbox": [ + 198, + 497, + 208, + 506 + ], + "score": 0.83, + "content": "a _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 495, + 298, + 507 + ], + "score": 1.0, + "content": "and observe new state", + "type": "text" + }, + { + "bbox": [ + 299, + 497, + 318, + 507 + ], + "score": 0.89, + "content": "s _ { t + 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 318, + 495, + 368, + 507 + ], + "score": 1.0, + "content": ", and reward", + "type": "text" + }, + { + "bbox": [ + 369, + 497, + 378, + 506 + ], + "score": 0.83, + "content": "r _ { t }", + "type": "inline_equation" + } + ], + "index": 28 + }, + { + "bbox": [ + 135, + 505, + 325, + 519 + ], + "spans": [ + { + "bbox": [ + 135, + 505, + 200, + 519 + ], + "score": 1.0, + "content": "Store transition", + "type": "text" + }, + { + "bbox": [ + 201, + 507, + 264, + 518 + ], + "score": 0.9, + "content": "( s _ { t } , a _ { t } , r _ { t } , s _ { t + 1 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 505, + 312, + 519 + ], + "score": 1.0, + "content": "in memory", + "type": "text" + }, + { + "bbox": [ + 313, + 507, + 325, + 516 + ], + "score": 0.81, + "content": "\\mathcal { M }", + "type": "inline_equation" + } + ], + "index": 29 + }, + { + "bbox": [ + 126, + 517, + 160, + 528 + ], + "spans": [ + { + "bbox": [ + 126, + 517, + 160, + 528 + ], + "score": 1.0, + "content": "end for", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 116, + 528, + 150, + 540 + ], + "spans": [ + { + "bbox": [ + 116, + 528, + 150, + 540 + ], + "score": 1.0, + "content": "end for", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 27 + }, + { + "type": "title", + "bbox": [ + 107, + 578, + 193, + 589 + ], + "lines": [ + { + "bbox": [ + 105, + 577, + 195, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 195, + 592 + ], + "score": 1.0, + "content": "Algorithm 2 Learner", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "title", + "bbox": [ + 117, + 592, + 146, + 602 + ], + "lines": [ + { + "bbox": [ + 115, + 590, + 148, + 605 + ], + "spans": [ + { + "bbox": [ + 115, + 590, + 148, + 605 + ], + "score": 1.0, + "content": "Given:", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 142, + 605, + 332, + 638 + ], + "lines": [ + { + "bbox": [ + 142, + 605, + 272, + 615 + ], + "spans": [ + { + "bbox": [ + 142, + 605, + 272, + 615 + ], + "score": 1.0, + "content": "• an off-policy RL algorithm A", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 142, + 616, + 226, + 626 + ], + "spans": [ + { + "bbox": [ + 142, + 616, + 213, + 626 + ], + "score": 1.0, + "content": "• a replay buffer", + "type": "text" + }, + { + "bbox": [ + 213, + 616, + 226, + 626 + ], + "score": 0.52, + "content": "\\mathcal { M }", + "type": "inline_equation" + } + ], + "index": 35 + }, + { + "bbox": [ + 142, + 626, + 332, + 639 + ], + "spans": [ + { + "bbox": [ + 142, + 626, + 315, + 639 + ], + "score": 1.0, + "content": "• a replay buffer of expert demonstrations", + "type": "text" + }, + { + "bbox": [ + 315, + 627, + 332, + 637 + ], + "score": 0.84, + "content": "\\mathcal { M } _ { e }", + "type": "inline_equation" + } + ], + "index": 36 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 116, + 645, + 417, + 727 + ], + "lines": [ + { + "bbox": [ + 116, + 641, + 164, + 651 + ], + "spans": [ + { + "bbox": [ + 116, + 641, + 164, + 651 + ], + "score": 1.0, + "content": "Initialize A", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 114, + 649, + 182, + 664 + ], + "spans": [ + { + "bbox": [ + 114, + 649, + 131, + 664 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 132, + 651, + 167, + 662 + ], + "score": 0.31, + "content": "n _ { u p d a t e s }", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 649, + 182, + 664 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 126, + 661, + 402, + 674 + ], + "spans": [ + { + "bbox": [ + 126, + 661, + 203, + 674 + ], + "score": 1.0, + "content": "Sample transitions", + "type": "text" + }, + { + "bbox": [ + 203, + 662, + 268, + 673 + ], + "score": 0.77, + "content": "\\left( { { s _ { t } } , { a _ { t } } , { r _ { t } } , { s _ { t + 1 } } } \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 661, + 291, + 674 + ], + "score": 1.0, + "content": "from", + "type": "text" + }, + { + "bbox": [ + 292, + 662, + 304, + 672 + ], + "score": 0.84, + "content": "\\mathcal { M }", + "type": "inline_equation" + }, + { + "bbox": [ + 305, + 661, + 389, + 674 + ], + "score": 1.0, + "content": "to make a minibatch", + "type": "text" + }, + { + "bbox": [ + 389, + 662, + 398, + 671 + ], + "score": 0.8, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 661, + 402, + 674 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 125, + 671, + 412, + 685 + ], + "spans": [ + { + "bbox": [ + 125, + 671, + 203, + 685 + ], + "score": 1.0, + "content": "Sample transitions", + "type": "text" + }, + { + "bbox": [ + 203, + 673, + 268, + 684 + ], + "score": 0.88, + "content": "\\left( { { s _ { t } } , { a _ { t } } , { r _ { t } } , { s _ { t + 1 } } } \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 671, + 291, + 685 + ], + "score": 1.0, + "content": "from", + "type": "text" + }, + { + "bbox": [ + 292, + 673, + 309, + 683 + ], + "score": 0.89, + "content": "\\mathcal { M } _ { e }", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 671, + 398, + 685 + ], + "score": 1.0, + "content": "enlarge the minibatch", + "type": "text" + }, + { + "bbox": [ + 399, + 673, + 408, + 682 + ], + "score": 0.78, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 671, + 412, + 685 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 125, + 683, + 297, + 695 + ], + "spans": [ + { + "bbox": [ + 125, + 683, + 297, + 695 + ], + "score": 1.0, + "content": "Perform a actor update step with Eqn. (5).", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 125, + 693, + 297, + 707 + ], + "spans": [ + { + "bbox": [ + 125, + 693, + 297, + 707 + ], + "score": 1.0, + "content": "Perform a critic update step with Eqn. (6).", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 125, + 704, + 339, + 718 + ], + "spans": [ + { + "bbox": [ + 125, + 704, + 306, + 718 + ], + "score": 1.0, + "content": "Update the target actor/critic networks every", + "type": "text" + }, + { + "bbox": [ + 306, + 705, + 313, + 715 + ], + "score": 0.79, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 704, + 339, + 718 + ], + "score": 1.0, + "content": "steps.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 715, + 150, + 728 + ], + "spans": [ + { + "bbox": [ + 115, + 715, + 150, + 728 + ], + "score": 1.0, + "content": "end for", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 40.5 + } + ], + "page_idx": 14, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 26, + 308, + 38 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 308, + 39 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 308, + 39 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 346, + 95 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 347, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 147, + 96 + ], + "score": 1.0, + "content": "Given the", + "type": "text" + }, + { + "bbox": [ + 147, + 83, + 157, + 94 + ], + "score": 0.85, + "content": "Q", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 81, + 347, + 96 + ], + "score": 1.0, + "content": "function, we can update the policy using DPG:", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0, + "bbox_fs": [ + 106, + 81, + 347, + 96 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 226, + 104, + 385, + 119 + ], + "lines": [ + { + "bbox": [ + 226, + 104, + 385, + 119 + ], + "spans": [ + { + "bbox": [ + 226, + 104, + 385, + 119 + ], + "score": 0.92, + "content": "\\mathcal { I } ( \\phi ) = \\mathbb { E } _ { s _ { t } \\sim \\mathcal { M } } \\left[ \\nabla _ { \\phi } Q ( s _ { t } , \\pi ( s _ { t } | \\phi ) | \\theta ) \\right] .", + "type": "interline_equation", + "image_path": "d9a9a466471a108f418f609eafa9bc0cc7366850e41f8714acb68e7b0816f19e.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 226, + 104, + 385, + 119 + ], + "spans": [], + "index": 1 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 135, + 505, + 185 + ], + "lines": [ + { + "bbox": [ + 105, + 133, + 506, + 148 + ], + "spans": [ + { + "bbox": [ + 105, + 133, + 217, + 148 + ], + "score": 1.0, + "content": "Instead of using a scalar", + "type": "text" + }, + { + "bbox": [ + 217, + 136, + 227, + 147 + ], + "score": 0.8, + "content": "Q", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 133, + 506, + 148 + ], + "score": 1.0, + "content": "function, D4PG adopts a distributional value function such that", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 145, + 505, + 160 + ], + "spans": [ + { + "bbox": [ + 106, + 146, + 226, + 159 + ], + "score": 0.9, + "content": "Q ( s _ { t } , a | \\theta ) ~ = ~ \\bar { \\mathbb { E } } \\big [ Z ( s _ { t } , a | \\theta ) \\big ]", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 145, + 260, + 160 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 260, + 147, + 269, + 157 + ], + "score": 0.82, + "content": "Z", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 145, + 410, + 160 + ], + "score": 1.0, + "content": "is a random variable such that", + "type": "text" + }, + { + "bbox": [ + 410, + 147, + 449, + 158 + ], + "score": 0.91, + "content": "Z ~ = ~ z _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 145, + 479, + 160 + ], + "score": 1.0, + "content": "w.p.", + "type": "text" + }, + { + "bbox": [ + 479, + 148, + 505, + 158 + ], + "score": 0.81, + "content": "\\qquad p _ { i } \\propto", + "type": "inline_equation" + } + ], + "index": 3 + }, + { + "bbox": [ + 107, + 158, + 505, + 172 + ], + "spans": [ + { + "bbox": [ + 107, + 159, + 169, + 171 + ], + "score": 0.89, + "content": "\\exp ( \\omega ( s _ { t } , a | \\theta ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 158, + 195, + 172 + ], + "score": 1.0, + "content": ". The", + "type": "text" + }, + { + "bbox": [ + 196, + 160, + 205, + 169 + ], + "score": 0.82, + "content": "z _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 158, + 247, + 172 + ], + "score": 1.0, + "content": "’s take on", + "type": "text" + }, + { + "bbox": [ + 247, + 159, + 270, + 169 + ], + "score": 0.89, + "content": "V _ { b i n s }", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 158, + 463, + 172 + ], + "score": 1.0, + "content": "discrete values that ranges uniformly between", + "type": "text" + }, + { + "bbox": [ + 464, + 159, + 486, + 170 + ], + "score": 0.91, + "content": "V _ { m i n }", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 158, + 505, + 172 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 107, + 166, + 389, + 188 + ], + "spans": [ + { + "bbox": [ + 107, + 171, + 130, + 182 + ], + "score": 0.88, + "content": "V _ { m a x }", + "type": "inline_equation" + }, + { + "bbox": [ + 130, + 166, + 169, + 188 + ], + "score": 1.0, + "content": "such that", + "type": "text" + }, + { + "bbox": [ + 169, + 170, + 274, + 185 + ], + "score": 0.92, + "content": "\\begin{array} { r } { z _ { i } = V _ { m i n } + i \\frac { V _ { m a x } - V _ { m i n } } { V _ { b i n s } } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 274, + 166, + 290, + 188 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 290, + 170, + 384, + 183 + ], + "score": 0.89, + "content": "i \\in \\{ 0 , \\cdots , V _ { b i n s } - 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 384, + 166, + 389, + 188 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 133, + 506, + 188 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 188, + 505, + 247 + ], + "lines": [ + { + "bbox": [ + 105, + 188, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 282, + 201 + ], + "score": 1.0, + "content": "To construct a bootstrap target, D4PG uses", + "type": "text" + }, + { + "bbox": [ + 282, + 190, + 292, + 199 + ], + "score": 0.32, + "content": "\\mathbf { N } .", + "type": "inline_equation" + }, + { + "bbox": [ + 292, + 188, + 505, + 201 + ], + "score": 1.0, + "content": "-step returns. Given a sampled tuple from the replay", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 199, + 507, + 213 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 147, + 213 + ], + "score": 1.0, + "content": "memory:", + "type": "text" + }, + { + "bbox": [ + 147, + 200, + 295, + 212 + ], + "score": 0.87, + "content": "s _ { t } , a _ { t } , \\{ r _ { t } , r _ { t + 1 } , \\cdot \\cdot \\cdot , r _ { t + N - 1 } \\} , s _ { t + N }", + "type": "inline_equation" + }, + { + "bbox": [ + 296, + 199, + 452, + 213 + ], + "score": 1.0, + "content": ", we construct a new random variable", + "type": "text" + }, + { + "bbox": [ + 452, + 200, + 464, + 210 + ], + "score": 0.87, + "content": "Z ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 199, + 507, + 213 + ], + "score": 1.0, + "content": "such that", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 209, + 507, + 228 + ], + "spans": [ + { + "bbox": [ + 104, + 209, + 184, + 228 + ], + "score": 1.0, + "content": "Z0 = zi + PN−1n=0", + "type": "text" + }, + { + "bbox": [ + 213, + 210, + 236, + 227 + ], + "score": 1.0, + "content": "w.p.", + "type": "text" + }, + { + "bbox": [ + 237, + 213, + 380, + 225 + ], + "score": 0.9, + "content": "p _ { i } \\propto \\exp ( \\omega ( s _ { t + N } , \\pi ( s _ { t + N } | \\phi ^ { \\prime } ) | \\theta ^ { \\prime } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 210, + 418, + 227 + ], + "score": 1.0, + "content": ". Notice,", + "type": "text" + }, + { + "bbox": [ + 419, + 213, + 430, + 223 + ], + "score": 0.86, + "content": "Z ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 430, + 210, + 507, + 227 + ], + "score": 1.0, + "content": "no longer has the", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 223, + 505, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 223, + 325, + 236 + ], + "score": 1.0, + "content": "same support. We therefore adopt the same projection", + "type": "text" + }, + { + "bbox": [ + 325, + 225, + 334, + 234 + ], + "score": 0.79, + "content": "\\Phi", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 223, + 505, + 236 + ], + "score": 1.0, + "content": "employed by Bellemare et al. (2017). The", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 235, + 246, + 247 + ], + "spans": [ + { + "bbox": [ + 106, + 235, + 246, + 247 + ], + "score": 1.0, + "content": "training loss for the value function", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8, + "bbox_fs": [ + 104, + 188, + 507, + 247 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 177, + 257, + 433, + 272 + ], + "lines": [ + { + "bbox": [ + 177, + 257, + 433, + 272 + ], + "spans": [ + { + "bbox": [ + 177, + 257, + 433, + 272 + ], + "score": 0.87, + "content": "\\mathcal { L } ( \\theta ) = \\mathbb { E } _ { s _ { t } , a _ { t } , \\{ r _ { t } , \\cdots , r _ { t + N - 1 } \\} , s _ { t + N } \\sim \\mathcal { M } } \\big [ H \\big ( \\Phi ( Z ^ { \\prime } ) , Z ( s _ { t } , a _ { t } | \\theta ) \\big ) \\big ] ,", + "type": "interline_equation", + "image_path": "4325c14ac5c5caff010358a3b8f4b5186d28590f7cd88b92da06c98b8b3dfb6a.jpg" + } + ] + } + ], + "index": 11, + "virtual_lines": [ + { + "bbox": [ + 177, + 257, + 433, + 272 + ], + "spans": [], + "index": 11 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 282, + 225, + 294 + ], + "lines": [ + { + "bbox": [ + 106, + 280, + 226, + 297 + ], + "spans": [ + { + "bbox": [ + 106, + 280, + 133, + 297 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 283, + 143, + 292 + ], + "score": 0.84, + "content": "H", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 280, + 226, + 297 + ], + "score": 1.0, + "content": "is the cross entropy.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12, + "bbox_fs": [ + 106, + 280, + 226, + 297 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 298, + 506, + 366 + ], + "lines": [ + { + "bbox": [ + 105, + 298, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 505, + 312 + ], + "score": 1.0, + "content": "D4PG is also distributed following Horgan et al. (2018). Since all learning processes only rely on", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 309, + 506, + 322 + ], + "spans": [ + { + "bbox": [ + 106, + 309, + 506, + 322 + ], + "score": 1.0, + "content": "the replay memory, we can easily decouple the ‘actors’ from the ‘learners’. D4PG therefore uses a", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 321, + 506, + 334 + ], + "spans": [ + { + "bbox": [ + 105, + 321, + 506, + 334 + ], + "score": 1.0, + "content": "large number of independent actor processes which act in the environment and write data to a central", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 104, + 331, + 507, + 346 + ], + "spans": [ + { + "bbox": [ + 104, + 331, + 507, + 346 + ], + "score": 1.0, + "content": "replay memory process. The learners could then draw samples from the replay memory for learning.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 342, + 505, + 356 + ], + "spans": [ + { + "bbox": [ + 105, + 342, + 505, + 356 + ], + "score": 1.0, + "content": "The learner also serves as a parameter server to the actors which periodically update their policy", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 354, + 221, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 354, + 221, + 365 + ], + "score": 1.0, + "content": "parameters from the learner.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15.5, + "bbox_fs": [ + 104, + 298, + 507, + 365 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 371, + 505, + 405 + ], + "lines": [ + { + "bbox": [ + 105, + 370, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 505, + 384 + ], + "score": 1.0, + "content": "In our experiments, we always have access to expert demonstrations. We, therefore adopt the practice", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 381, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 505, + 394 + ], + "score": 1.0, + "content": "from DQfD and DDPGfD and put the demonstrations into our replay buffers. For more details see", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 393, + 174, + 406 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 174, + 406 + ], + "score": 1.0, + "content": "Algorithms 1, 2.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20, + "bbox_fs": [ + 105, + 370, + 505, + 406 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 423, + 185, + 434 + ], + "lines": [ + { + "bbox": [ + 105, + 422, + 186, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 422, + 186, + 436 + ], + "score": 1.0, + "content": "Algorithm 1 Actor", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "list", + "bbox": [ + 109, + 437, + 380, + 540 + ], + "lines": [ + { + "bbox": [ + 115, + 435, + 148, + 450 + ], + "spans": [ + { + "bbox": [ + 115, + 435, + 148, + 450 + ], + "score": 1.0, + "content": "Given:", + "type": "text" + } + ], + "index": 23, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 142, + 450, + 286, + 461 + ], + "spans": [ + { + "bbox": [ + 142, + 450, + 273, + 461 + ], + "score": 1.0, + "content": "• an experience replay memory", + "type": "text" + }, + { + "bbox": [ + 273, + 450, + 286, + 460 + ], + "score": 0.67, + "content": "\\mathcal { M }", + "type": "inline_equation" + } + ], + "index": 24, + "is_list_end_line": true + }, + { + "bbox": [ + 115, + 462, + 185, + 475 + ], + "spans": [ + { + "bbox": [ + 115, + 462, + 131, + 475 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 131, + 464, + 169, + 474 + ], + "score": 0.26, + "content": "n _ { e p i s o d e s }", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 462, + 185, + 475 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 25, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 126, + 473, + 199, + 484 + ], + "spans": [ + { + "bbox": [ + 126, + 473, + 141, + 484 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 141, + 474, + 165, + 483 + ], + "score": 0.86, + "content": "t = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 473, + 176, + 484 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 176, + 474, + 185, + 483 + ], + "score": 0.69, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 473, + 199, + 484 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 26, + "is_list_end_line": true + }, + { + "bbox": [ + 136, + 483, + 314, + 497 + ], + "spans": [ + { + "bbox": [ + 136, + 483, + 266, + 497 + ], + "score": 1.0, + "content": "Sample action from task policy:", + "type": "text" + }, + { + "bbox": [ + 267, + 484, + 314, + 496 + ], + "score": 0.92, + "content": "\\boldsymbol { a } _ { t } \\gets \\pi ( \\boldsymbol { s } _ { t } )", + "type": "inline_equation" + } + ], + "index": 27, + "is_list_end_line": true + }, + { + "bbox": [ + 136, + 495, + 378, + 507 + ], + "spans": [ + { + "bbox": [ + 136, + 495, + 197, + 507 + ], + "score": 1.0, + "content": "Execute action", + "type": "text" + }, + { + "bbox": [ + 198, + 497, + 208, + 506 + ], + "score": 0.83, + "content": "a _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 495, + 298, + 507 + ], + "score": 1.0, + "content": "and observe new state", + "type": "text" + }, + { + "bbox": [ + 299, + 497, + 318, + 507 + ], + "score": 0.89, + "content": "s _ { t + 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 318, + 495, + 368, + 507 + ], + "score": 1.0, + "content": ", and reward", + "type": "text" + }, + { + "bbox": [ + 369, + 497, + 378, + 506 + ], + "score": 0.83, + "content": "r _ { t }", + "type": "inline_equation" + } + ], + "index": 28 + }, + { + "bbox": [ + 135, + 505, + 325, + 519 + ], + "spans": [ + { + "bbox": [ + 135, + 505, + 200, + 519 + ], + "score": 1.0, + "content": "Store transition", + "type": "text" + }, + { + "bbox": [ + 201, + 507, + 264, + 518 + ], + "score": 0.9, + "content": "( s _ { t } , a _ { t } , r _ { t } , s _ { t + 1 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 505, + 312, + 519 + ], + "score": 1.0, + "content": "in memory", + "type": "text" + }, + { + "bbox": [ + 313, + 507, + 325, + 516 + ], + "score": 0.81, + "content": "\\mathcal { M }", + "type": "inline_equation" + } + ], + "index": 29, + "is_list_end_line": true + }, + { + "bbox": [ + 126, + 517, + 160, + 528 + ], + "spans": [ + { + "bbox": [ + 126, + 517, + 160, + 528 + ], + "score": 1.0, + "content": "end for", + "type": "text" + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 116, + 528, + 150, + 540 + ], + "spans": [ + { + "bbox": [ + 116, + 528, + 150, + 540 + ], + "score": 1.0, + "content": "end for", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true, + "is_list_end_line": true + } + ], + "index": 27, + "bbox_fs": [ + 115, + 435, + 378, + 540 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 578, + 193, + 589 + ], + "lines": [ + { + "bbox": [ + 105, + 577, + 195, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 195, + 592 + ], + "score": 1.0, + "content": "Algorithm 2 Learner", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "title", + "bbox": [ + 117, + 592, + 146, + 602 + ], + "lines": [ + { + "bbox": [ + 115, + 590, + 148, + 605 + ], + "spans": [ + { + "bbox": [ + 115, + 590, + 148, + 605 + ], + "score": 1.0, + "content": "Given:", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 142, + 605, + 332, + 638 + ], + "lines": [ + { + "bbox": [ + 142, + 605, + 272, + 615 + ], + "spans": [ + { + "bbox": [ + 142, + 605, + 272, + 615 + ], + "score": 1.0, + "content": "• an off-policy RL algorithm A", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 142, + 616, + 226, + 626 + ], + "spans": [ + { + "bbox": [ + 142, + 616, + 213, + 626 + ], + "score": 1.0, + "content": "• a replay buffer", + "type": "text" + }, + { + "bbox": [ + 213, + 616, + 226, + 626 + ], + "score": 0.52, + "content": "\\mathcal { M }", + "type": "inline_equation" + } + ], + "index": 35 + }, + { + "bbox": [ + 142, + 626, + 332, + 639 + ], + "spans": [ + { + "bbox": [ + 142, + 626, + 315, + 639 + ], + "score": 1.0, + "content": "• a replay buffer of expert demonstrations", + "type": "text" + }, + { + "bbox": [ + 315, + 627, + 332, + 637 + ], + "score": 0.84, + "content": "\\mathcal { M } _ { e }", + "type": "inline_equation" + } + ], + "index": 36 + } + ], + "index": 35, + "bbox_fs": [ + 142, + 605, + 332, + 639 + ] + }, + { + "type": "list", + "bbox": [ + 116, + 645, + 417, + 727 + ], + "lines": [ + { + "bbox": [ + 116, + 641, + 164, + 651 + ], + "spans": [ + { + "bbox": [ + 116, + 641, + 164, + 651 + ], + "score": 1.0, + "content": "Initialize A", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 114, + 649, + 182, + 664 + ], + "spans": [ + { + "bbox": [ + 114, + 649, + 131, + 664 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 132, + 651, + 167, + 662 + ], + "score": 0.31, + "content": "n _ { u p d a t e s }", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 649, + 182, + 664 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 38, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 126, + 661, + 402, + 674 + ], + "spans": [ + { + "bbox": [ + 126, + 661, + 203, + 674 + ], + "score": 1.0, + "content": "Sample transitions", + "type": "text" + }, + { + "bbox": [ + 203, + 662, + 268, + 673 + ], + "score": 0.77, + "content": "\\left( { { s _ { t } } , { a _ { t } } , { r _ { t } } , { s _ { t + 1 } } } \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 661, + 291, + 674 + ], + "score": 1.0, + "content": "from", + "type": "text" + }, + { + "bbox": [ + 292, + 662, + 304, + 672 + ], + "score": 0.84, + "content": "\\mathcal { M }", + "type": "inline_equation" + }, + { + "bbox": [ + 305, + 661, + 389, + 674 + ], + "score": 1.0, + "content": "to make a minibatch", + "type": "text" + }, + { + "bbox": [ + 389, + 662, + 398, + 671 + ], + "score": 0.8, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 661, + 402, + 674 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 125, + 671, + 412, + 685 + ], + "spans": [ + { + "bbox": [ + 125, + 671, + 203, + 685 + ], + "score": 1.0, + "content": "Sample transitions", + "type": "text" + }, + { + "bbox": [ + 203, + 673, + 268, + 684 + ], + "score": 0.88, + "content": "\\left( { { s _ { t } } , { a _ { t } } , { r _ { t } } , { s _ { t + 1 } } } \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 671, + 291, + 685 + ], + "score": 1.0, + "content": "from", + "type": "text" + }, + { + "bbox": [ + 292, + 673, + 309, + 683 + ], + "score": 0.89, + "content": "\\mathcal { M } _ { e }", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 671, + 398, + 685 + ], + "score": 1.0, + "content": "enlarge the minibatch", + "type": "text" + }, + { + "bbox": [ + 399, + 673, + 408, + 682 + ], + "score": 0.78, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 671, + 412, + 685 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 125, + 683, + 297, + 695 + ], + "spans": [ + { + "bbox": [ + 125, + 683, + 297, + 695 + ], + "score": 1.0, + "content": "Perform a actor update step with Eqn. (5).", + "type": "text" + } + ], + "index": 41, + "is_list_end_line": true + }, + { + "bbox": [ + 125, + 693, + 297, + 707 + ], + "spans": [ + { + "bbox": [ + 125, + 693, + 297, + 707 + ], + "score": 1.0, + "content": "Perform a critic update step with Eqn. (6).", + "type": "text" + } + ], + "index": 42, + "is_list_end_line": true + }, + { + "bbox": [ + 125, + 704, + 339, + 718 + ], + "spans": [ + { + "bbox": [ + 125, + 704, + 306, + 718 + ], + "score": 1.0, + "content": "Update the target actor/critic networks every", + "type": "text" + }, + { + "bbox": [ + 306, + 705, + 313, + 715 + ], + "score": 0.79, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 704, + 339, + 718 + ], + "score": 1.0, + "content": "steps.", + "type": "text" + } + ], + "index": 43, + "is_list_end_line": true + }, + { + "bbox": [ + 115, + 715, + 150, + 728 + ], + "spans": [ + { + "bbox": [ + 115, + 715, + 150, + 728 + ], + "score": 1.0, + "content": "end for", + "type": "text" + } + ], + "index": 44, + "is_list_start_line": true, + "is_list_end_line": true + } + ], + "index": 40.5, + "bbox_fs": [ + 114, + 641, + 412, + 728 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 83, + 356, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 358, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 358, + 95 + ], + "score": 1.0, + "content": "A.7 NETWORK ARCHITECTURE AND HYPERPARAMETERS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 104, + 506, + 137 + ], + "lines": [ + { + "bbox": [ + 105, + 104, + 506, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 506, + 116 + ], + "score": 1.0, + "content": "Actor and critic share a residual pixel encoder network with eight convolutional layers (3x3 convolu-", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 114, + 506, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 506, + 127 + ], + "score": 1.0, + "content": "tions, three 2-layer blocks with 16, 32, 32 channels), instance normalization (Ulyanov et al., 2016)", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 125, + 369, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 125, + 369, + 139 + ], + "score": 1.0, + "content": "and exponential linear units (Clevert et al., 2015) between layers.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 106, + 142, + 505, + 177 + ], + "lines": [ + { + "bbox": [ + 105, + 142, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 505, + 155 + ], + "score": 1.0, + "content": "The policy is a 3-layer MLP with ReLU activations with hidden layer sizes (300, 200). The critic is", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 153, + 505, + 166 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 505, + 166 + ], + "score": 1.0, + "content": "a 3-layer MLP with ReLU activations with hidden layer sizes (400, 300). For a illustration of the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 165, + 231, + 177 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 231, + 177 + ], + "score": 1.0, + "content": "network. Please see Figure 15.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5 + }, + { + "type": "image", + "bbox": [ + 106, + 188, + 502, + 289 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 188, + 502, + 289 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 188, + 502, + 289 + ], + "spans": [ + { + "bbox": [ + 106, + 188, + 502, + 289 + ], + "score": 0.962, + "type": "image", + "image_path": "28c5f55c9a59fb03ff40780ca1b034a37b8cd5bc60d7b421bfe54857e6457a48.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 106, + 188, + 502, + 221.66666666666666 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 106, + 221.66666666666666, + 502, + 255.33333333333331 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 106, + 255.33333333333331, + 502, + 289.0 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 189, + 308, + 418, + 321 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 188, + 307, + 419, + 323 + ], + "spans": [ + { + "bbox": [ + 188, + 307, + 419, + 323 + ], + "score": 1.0, + "content": "Figure 15: Network architecture for the policy and critic.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + } + ], + "index": 9.0 + }, + { + "type": "text", + "bbox": [ + 106, + 333, + 504, + 356 + ], + "lines": [ + { + "bbox": [ + 106, + 333, + 505, + 346 + ], + "spans": [ + { + "bbox": [ + 106, + 333, + 505, + 346 + ], + "score": 1.0, + "content": "The discriminator network uses a pixel encoder of the same architecture as the actor critic, followed", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 344, + 400, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 400, + 358 + ], + "score": 1.0, + "content": "by a 3-layer MLP with ReLU activations and hidden layer sizes (32, 32).", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + }, + { + "type": "table", + "bbox": [ + 171, + 379, + 437, + 623 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 171, + 379, + 437, + 623 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 171, + 379, + 437, + 623 + ], + "spans": [ + { + "bbox": [ + 171, + 379, + 437, + 623 + ], + "score": 0.976, + "html": "
ParametersValues
Actor/Critic Input Width64
Actor/Critic Input Height64
D4PG Parameters
Vmin-50
Vmax150
Vbins21
N step1
Actor learning rate10-4
Critic learning rate10-4
OptimizerAdam (Kingma & Ba (2014))
Batch size256
Target update period100
Discount factor (y)0.99
Replay capacity106
Number of actors32 or 128
Imitation Parameters
Discriminator learning rate10-4
Discriminator Input Width48
Discriminator Input Height48
", + "type": "table", + "image_path": "8d79a56e3510372616f21696af491774a0fb484005300365e419100ca1e2c249.jpg" + } + ] + } + ], + "index": 21.5, + "virtual_lines": [ + { + "bbox": [ + 171, + 379, + 437, + 392.55555555555554 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 171, + 392.55555555555554, + 437, + 406.1111111111111 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 171, + 406.1111111111111, + 437, + 419.66666666666663 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 171, + 419.66666666666663, + 437, + 433.2222222222222 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 171, + 433.2222222222222, + 437, + 446.7777777777777 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 171, + 446.7777777777777, + 437, + 460.33333333333326 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 171, + 460.33333333333326, + 437, + 473.8888888888888 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 171, + 473.8888888888888, + 437, + 487.44444444444434 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 171, + 487.44444444444434, + 437, + 500.9999999999999 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 171, + 500.9999999999999, + 437, + 514.5555555555554 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 171, + 514.5555555555554, + 437, + 528.111111111111 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 171, + 528.111111111111, + 437, + 541.6666666666665 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 171, + 541.6666666666665, + 437, + 555.2222222222221 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 171, + 555.2222222222221, + 437, + 568.7777777777776 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 171, + 568.7777777777776, + 437, + 582.3333333333331 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 171, + 582.3333333333331, + 437, + 595.8888888888887 + ], + "spans": [], + "index": 28 + }, + { + "bbox": [ + 171, + 595.8888888888887, + 437, + 609.4444444444442 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 171, + 609.4444444444442, + 437, + 622.9999999999998 + ], + "spans": [], + "index": 30 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 169, + 631, + 441, + 643 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 168, + 629, + 442, + 645 + ], + "spans": [ + { + "bbox": [ + 168, + 629, + 442, + 645 + ], + "score": 1.0, + "content": "Table 3: Hyper parameters used in robot manipulation experiments.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + } + ], + "index": 26.25 + }, + { + "type": "title", + "bbox": [ + 106, + 666, + 372, + 677 + ], + "lines": [ + { + "bbox": [ + 106, + 666, + 372, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 372, + 678 + ], + "score": 1.0, + "content": "A.8 COMPARING AGAINST LEARNING WITH FIXED REWARDS", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "To check whether learned discriminators are needed, we compare TRAIL against agents using a fixed", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 698, + 507, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 244, + 712 + ], + "score": 1.0, + "content": "reward function corresponding to", + "type": "text" + }, + { + "bbox": [ + 245, + 699, + 295, + 711 + ], + "score": 0.91, + "content": "R _ { e x p e r t } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 698, + 313, + 712 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 314, + 699, + 361, + 711 + ], + "score": 0.91, + "content": "R _ { a g e n t } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 698, + 507, + 712 + ], + "score": 1.0, + "content": "for the lift alone and lift distracted", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "tasks. This baseline simulates an oracle discriminator with perfect generalization, but which is", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "agnostic to behavior. On the lift alone task, agents using this fixed reward achieve roughly half the", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34.5 + } + ], + "page_idx": 15, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 83, + 356, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 358, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 358, + 95 + ], + "score": 1.0, + "content": "A.7 NETWORK ARCHITECTURE AND HYPERPARAMETERS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 104, + 506, + 137 + ], + "lines": [ + { + "bbox": [ + 105, + 104, + 506, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 506, + 116 + ], + "score": 1.0, + "content": "Actor and critic share a residual pixel encoder network with eight convolutional layers (3x3 convolu-", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 114, + 506, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 506, + 127 + ], + "score": 1.0, + "content": "tions, three 2-layer blocks with 16, 32, 32 channels), instance normalization (Ulyanov et al., 2016)", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 125, + 369, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 125, + 369, + 139 + ], + "score": 1.0, + "content": "and exponential linear units (Clevert et al., 2015) between layers.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2, + "bbox_fs": [ + 105, + 104, + 506, + 139 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 142, + 505, + 177 + ], + "lines": [ + { + "bbox": [ + 105, + 142, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 505, + 155 + ], + "score": 1.0, + "content": "The policy is a 3-layer MLP with ReLU activations with hidden layer sizes (300, 200). The critic is", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 153, + 505, + 166 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 505, + 166 + ], + "score": 1.0, + "content": "a 3-layer MLP with ReLU activations with hidden layer sizes (400, 300). For a illustration of the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 165, + 231, + 177 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 231, + 177 + ], + "score": 1.0, + "content": "network. Please see Figure 15.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5, + "bbox_fs": [ + 105, + 142, + 505, + 177 + ] + }, + { + "type": "image", + "bbox": [ + 106, + 188, + 502, + 289 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 188, + 502, + 289 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 188, + 502, + 289 + ], + "spans": [ + { + "bbox": [ + 106, + 188, + 502, + 289 + ], + "score": 0.962, + "type": "image", + "image_path": "28c5f55c9a59fb03ff40780ca1b034a37b8cd5bc60d7b421bfe54857e6457a48.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 106, + 188, + 502, + 221.66666666666666 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 106, + 221.66666666666666, + 502, + 255.33333333333331 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 106, + 255.33333333333331, + 502, + 289.0 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 189, + 308, + 418, + 321 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 188, + 307, + 419, + 323 + ], + "spans": [ + { + "bbox": [ + 188, + 307, + 419, + 323 + ], + "score": 1.0, + "content": "Figure 15: Network architecture for the policy and critic.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + } + ], + "index": 9.0 + }, + { + "type": "text", + "bbox": [ + 106, + 333, + 504, + 356 + ], + "lines": [ + { + "bbox": [ + 106, + 333, + 505, + 346 + ], + "spans": [ + { + "bbox": [ + 106, + 333, + 505, + 346 + ], + "score": 1.0, + "content": "The discriminator network uses a pixel encoder of the same architecture as the actor critic, followed", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 344, + 400, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 400, + 358 + ], + "score": 1.0, + "content": "by a 3-layer MLP with ReLU activations and hidden layer sizes (32, 32).", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 333, + 505, + 358 + ] + }, + { + "type": "table", + "bbox": [ + 171, + 379, + 437, + 623 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 171, + 379, + 437, + 623 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 171, + 379, + 437, + 623 + ], + "spans": [ + { + "bbox": [ + 171, + 379, + 437, + 623 + ], + "score": 0.976, + "html": "
ParametersValues
Actor/Critic Input Width64
Actor/Critic Input Height64
D4PG Parameters
Vmin-50
Vmax150
Vbins21
N step1
Actor learning rate10-4
Critic learning rate10-4
OptimizerAdam (Kingma & Ba (2014))
Batch size256
Target update period100
Discount factor (y)0.99
Replay capacity106
Number of actors32 or 128
Imitation Parameters
Discriminator learning rate10-4
Discriminator Input Width48
Discriminator Input Height48
", + "type": "table", + "image_path": "8d79a56e3510372616f21696af491774a0fb484005300365e419100ca1e2c249.jpg" + } + ] + } + ], + "index": 21.5, + "virtual_lines": [ + { + "bbox": [ + 171, + 379, + 437, + 392.55555555555554 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 171, + 392.55555555555554, + 437, + 406.1111111111111 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 171, + 406.1111111111111, + 437, + 419.66666666666663 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 171, + 419.66666666666663, + 437, + 433.2222222222222 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 171, + 433.2222222222222, + 437, + 446.7777777777777 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 171, + 446.7777777777777, + 437, + 460.33333333333326 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 171, + 460.33333333333326, + 437, + 473.8888888888888 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 171, + 473.8888888888888, + 437, + 487.44444444444434 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 171, + 487.44444444444434, + 437, + 500.9999999999999 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 171, + 500.9999999999999, + 437, + 514.5555555555554 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 171, + 514.5555555555554, + 437, + 528.111111111111 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 171, + 528.111111111111, + 437, + 541.6666666666665 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 171, + 541.6666666666665, + 437, + 555.2222222222221 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 171, + 555.2222222222221, + 437, + 568.7777777777776 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 171, + 568.7777777777776, + 437, + 582.3333333333331 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 171, + 582.3333333333331, + 437, + 595.8888888888887 + ], + "spans": [], + "index": 28 + }, + { + "bbox": [ + 171, + 595.8888888888887, + 437, + 609.4444444444442 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 171, + 609.4444444444442, + 437, + 622.9999999999998 + ], + "spans": [], + "index": 30 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 169, + 631, + 441, + 643 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 168, + 629, + 442, + 645 + ], + "spans": [ + { + "bbox": [ + 168, + 629, + 442, + 645 + ], + "score": 1.0, + "content": "Table 3: Hyper parameters used in robot manipulation experiments.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + } + ], + "index": 26.25 + }, + { + "type": "title", + "bbox": [ + 106, + 666, + 372, + 677 + ], + "lines": [ + { + "bbox": [ + 106, + 666, + 372, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 372, + 678 + ], + "score": 1.0, + "content": "A.8 COMPARING AGAINST LEARNING WITH FIXED REWARDS", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "To check whether learned discriminators are needed, we compare TRAIL against agents using a fixed", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 698, + 507, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 244, + 712 + ], + "score": 1.0, + "content": "reward function corresponding to", + "type": "text" + }, + { + "bbox": [ + 245, + 699, + 295, + 711 + ], + "score": 0.91, + "content": "R _ { e x p e r t } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 698, + 313, + 712 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 314, + 699, + 361, + 711 + ], + "score": 0.91, + "content": "R _ { a g e n t } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 698, + 507, + 712 + ], + "score": 1.0, + "content": "for the lift alone and lift distracted", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "tasks. This baseline simulates an oracle discriminator with perfect generalization, but which is", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "agnostic to behavior. On the lift alone task, agents using this fixed reward achieve roughly half the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "reward of TRAIL asymptotically, and on lift distracted they do not solve the task (average rewards", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 363, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 363, + 106 + ], + "score": 1.0, + "content": "are less than 5). The learning curves are presented in Figure 16.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 687, + 507, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 104, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "reward of TRAIL asymptotically, and on lift distracted they do not solve the task (average rewards", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 363, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 363, + 106 + ], + "score": 1.0, + "content": "are less than 5). The learning curves are presented in Figure 16.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "image", + "bbox": [ + 180, + 116, + 424, + 234 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 180, + 116, + 424, + 234 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 180, + 116, + 424, + 234 + ], + "spans": [ + { + "bbox": [ + 180, + 116, + 424, + 234 + ], + "score": 0.969, + "type": "image", + "image_path": "73412ac4784215fb9164009bf367fa91028931791c266c531f38108dcd112e50.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 180, + 116, + 424, + 129.11111111111111 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 180, + 129.11111111111111, + 424, + 142.22222222222223 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 180, + 142.22222222222223, + 424, + 155.33333333333334 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 180, + 155.33333333333334, + 424, + 168.44444444444446 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 180, + 168.44444444444446, + 424, + 181.55555555555557 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 180, + 181.55555555555557, + 424, + 194.66666666666669 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 180, + 194.66666666666669, + 424, + 207.7777777777778 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 180, + 207.7777777777778, + 424, + 220.8888888888889 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 180, + 220.8888888888889, + 424, + 234.00000000000003 + ], + "spans": [], + "index": 10 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 247, + 505, + 270 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 247, + 505, + 260 + ], + "spans": [ + { + "bbox": [ + 106, + 247, + 505, + 260 + ], + "score": 1.0, + "content": "Figure 16: With fixed rewards, the agent is able to learn lift alone somewhat, but performs worse than", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 257, + 470, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 257, + 470, + 271 + ], + "score": 1.0, + "content": "TRAIL. When distractor blocks are added, the fixed reward agent fails to learn completely.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + } + ], + "index": 8.75 + } + ], + "page_idx": 16, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 104, + 82, + 504, + 105 + ], + "lines": [], + "index": 0.5, + "bbox_fs": [ + 105, + 82, + 505, + 106 + ], + "lines_deleted": true + }, + { + "type": "image", + "bbox": [ + 180, + 116, + 424, + 234 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 180, + 116, + 424, + 234 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 180, + 116, + 424, + 234 + ], + "spans": [ + { + "bbox": [ + 180, + 116, + 424, + 234 + ], + "score": 0.969, + "type": "image", + "image_path": "73412ac4784215fb9164009bf367fa91028931791c266c531f38108dcd112e50.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 180, + 116, + 424, + 129.11111111111111 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 180, + 129.11111111111111, + 424, + 142.22222222222223 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 180, + 142.22222222222223, + 424, + 155.33333333333334 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 180, + 155.33333333333334, + 424, + 168.44444444444446 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 180, + 168.44444444444446, + 424, + 181.55555555555557 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 180, + 181.55555555555557, + 424, + 194.66666666666669 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 180, + 194.66666666666669, + 424, + 207.7777777777778 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 180, + 207.7777777777778, + 424, + 220.8888888888889 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 180, + 220.8888888888889, + 424, + 234.00000000000003 + ], + "spans": [], + "index": 10 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 247, + 505, + 270 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 247, + 505, + 260 + ], + "spans": [ + { + "bbox": [ + 106, + 247, + 505, + 260 + ], + "score": 1.0, + "content": "Figure 16: With fixed rewards, the agent is able to learn lift alone somewhat, but performs worse than", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 257, + 470, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 257, + 470, + 271 + ], + "score": 1.0, + "content": "TRAIL. When distractor blocks are added, the fixed reward agent fails to learn completely.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + } + ], + "index": 8.75 + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file