diff --git "a/parse/train/bMCfFepJXM/bMCfFepJXM_middle.json" "b/parse/train/bMCfFepJXM/bMCfFepJXM_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/bMCfFepJXM/bMCfFepJXM_middle.json" @@ -0,0 +1,42515 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 503, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 77, + 505, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 77, + 156, + 97 + ], + "score": 1.0, + "content": "BRAC", + "type": "text" + }, + { + "bbox": [ + 156, + 81, + 168, + 95 + ], + "score": 0.29, + "content": "+", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 77, + 505, + 97 + ], + "score": 1.0, + "content": ": GOING DEEPER WITH BEHAVIOR REGULAR-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 99, + 428, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 99, + 428, + 118 + ], + "score": 1.0, + "content": "IZED OFFLINE REINFORCEMENT LEARNING", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 113, + 136, + 244, + 157 + ], + "lines": [ + { + "bbox": [ + 113, + 136, + 201, + 147 + ], + "spans": [ + { + "bbox": [ + 113, + 136, + 201, + 147 + ], + "score": 1.0, + "content": "Anonymous authors", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 111, + 146, + 245, + 158 + ], + "spans": [ + { + "bbox": [ + 111, + 146, + 245, + 158 + ], + "score": 1.0, + "content": "Paper under double-blind review", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5 + }, + { + "type": "title", + "bbox": [ + 278, + 186, + 333, + 199 + ], + "lines": [ + { + "bbox": [ + 276, + 186, + 335, + 200 + ], + "spans": [ + { + "bbox": [ + 276, + 186, + 335, + 200 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 143, + 211, + 468, + 453 + ], + "lines": [ + { + "bbox": [ + 141, + 210, + 470, + 225 + ], + "spans": [ + { + "bbox": [ + 141, + 210, + 470, + 225 + ], + "score": 1.0, + "content": "Online interactions with the environment to collect data samples for training a", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 223, + 469, + 235 + ], + "spans": [ + { + "bbox": [ + 141, + 223, + 469, + 235 + ], + "score": 1.0, + "content": "Reinforcement Learning agent is not always feasible due to economic and safety", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 233, + 469, + 246 + ], + "spans": [ + { + "bbox": [ + 141, + 233, + 469, + 246 + ], + "score": 1.0, + "content": "concerns. The goal of Offline Reinforcement Learning (RL) is to address this", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 142, + 245, + 469, + 257 + ], + "spans": [ + { + "bbox": [ + 142, + 245, + 469, + 257 + ], + "score": 1.0, + "content": "problem by learning effective policies using previously collected datasets. Stan-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 142, + 256, + 469, + 268 + ], + "spans": [ + { + "bbox": [ + 142, + 256, + 469, + 268 + ], + "score": 1.0, + "content": "dard off-policy RL algorithms are prone to overestimations of the values of out-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 142, + 267, + 469, + 279 + ], + "spans": [ + { + "bbox": [ + 142, + 267, + 469, + 279 + ], + "score": 1.0, + "content": "of-distribution (less explored) actions and are hence unsuitable for Offline RL.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 277, + 470, + 290 + ], + "spans": [ + { + "bbox": [ + 141, + 277, + 470, + 290 + ], + "score": 1.0, + "content": "Behavior regularization, which constraints the learned policy within the support", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 288, + 469, + 301 + ], + "spans": [ + { + "bbox": [ + 141, + 288, + 469, + 301 + ], + "score": 1.0, + "content": "set of the dataset, has been proposed to tackle the limitations of standard off-policy", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 142, + 300, + 469, + 311 + ], + "spans": [ + { + "bbox": [ + 142, + 300, + 469, + 311 + ], + "score": 1.0, + "content": "algorithms. In this paper, we improve the behavior regularized offline reinforce-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 311, + 469, + 322 + ], + "spans": [ + { + "bbox": [ + 141, + 311, + 255, + 322 + ], + "score": 1.0, + "content": "ment learning and propose", + "type": "text" + }, + { + "bbox": [ + 255, + 311, + 288, + 321 + ], + "score": 0.86, + "content": "B R A C +", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 311, + 469, + 322 + ], + "score": 1.0, + "content": ". We use an analytical upper bound on KL", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 142, + 322, + 469, + 334 + ], + "spans": [ + { + "bbox": [ + 142, + 322, + 469, + 334 + ], + "score": 1.0, + "content": "divergence as the behavior regularizor to reduce variance associated with sample", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 332, + 469, + 345 + ], + "spans": [ + { + "bbox": [ + 141, + 332, + 469, + 345 + ], + "score": 1.0, + "content": "based estimations. Additionally, we employ state-dependent Lagrange multipli-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 343, + 469, + 356 + ], + "spans": [ + { + "bbox": [ + 141, + 343, + 469, + 356 + ], + "score": 1.0, + "content": "ers for the regularization term to avoid distributing KL divergence penalty across", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 354, + 469, + 366 + ], + "spans": [ + { + "bbox": [ + 141, + 354, + 469, + 366 + ], + "score": 1.0, + "content": "all states of the sampled batch. The proposed Lagrange multipliers allow more", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 365, + 469, + 378 + ], + "spans": [ + { + "bbox": [ + 141, + 365, + 469, + 378 + ], + "score": 1.0, + "content": "freedom of deviation to high probability (more explored) states leading to better", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 377, + 469, + 388 + ], + "spans": [ + { + "bbox": [ + 141, + 377, + 469, + 388 + ], + "score": 1.0, + "content": "rewards while simultaneously restricting low probability (less explored) states to", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 141, + 387, + 469, + 399 + ], + "spans": [ + { + "bbox": [ + 141, + 387, + 469, + 399 + ], + "score": 1.0, + "content": "prevent out-of-distribution actions. To prevent catastrophic performance degra-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 398, + 469, + 410 + ], + "spans": [ + { + "bbox": [ + 141, + 398, + 469, + 410 + ], + "score": 1.0, + "content": "dation due to rare out-of-distribution actions, we add a gradient penalty term to", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 142, + 409, + 469, + 420 + ], + "spans": [ + { + "bbox": [ + 142, + 409, + 469, + 420 + ], + "score": 1.0, + "content": "the policy evaluation objective to penalize the gradient of the Q value w.r.t the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 141, + 420, + 469, + 432 + ], + "spans": [ + { + "bbox": [ + 141, + 420, + 469, + 432 + ], + "score": 1.0, + "content": "out-of-distribution actions. By doing so, the Q values evaluated at the out-of-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 142, + 430, + 469, + 442 + ], + "spans": [ + { + "bbox": [ + 142, + 430, + 434, + 442 + ], + "score": 1.0, + "content": "distribution actions are bounded. On challenging offline RL benchmarks,", + "type": "text" + }, + { + "bbox": [ + 434, + 431, + 469, + 442 + ], + "score": 0.37, + "content": "{ \\mathrm { B R A C } } +", + "type": "inline_equation" + } + ], + "index": 25 + }, + { + "bbox": [ + 141, + 441, + 436, + 455 + ], + "spans": [ + { + "bbox": [ + 141, + 441, + 436, + 455 + ], + "score": 1.0, + "content": "outperforms the state-of-the-art model-free and model-based approaches.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 15.5 + }, + { + "type": "title", + "bbox": [ + 108, + 475, + 206, + 487 + ], + "lines": [ + { + "bbox": [ + 105, + 474, + 208, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 208, + 491 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 500, + 505, + 555 + ], + "lines": [ + { + "bbox": [ + 105, + 498, + 506, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 506, + 515 + ], + "score": 1.0, + "content": "Reinforcement Learning (RL) has shown great success in a wide range of applications including", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 510, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 505, + 524 + ], + "score": 1.0, + "content": "board games (Silver et al., 2016), strategy games (Vinyals et al., 2019), energy systems (Zhang", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 523, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 505, + 534 + ], + "score": 1.0, + "content": "et al., 2019), robotics (Lin, 1992), recommendation systems (Choi et al., 2018), etc. The success of", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "score": 1.0, + "content": "RL relies heavily on extensive online interactions with the environment for exploration. However,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 543, + 505, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 505, + 557 + ], + "score": 1.0, + "content": "this is not always feasible in the real world as it can be expensive or dangerous (Levine et al., 2020).", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 107, + 561, + 504, + 649 + ], + "lines": [ + { + "bbox": [ + 105, + 560, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 505, + 574 + ], + "score": 1.0, + "content": "Offline RL, also known as batch RL, avoids online interactions with the environment by learning", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 572, + 504, + 583 + ], + "spans": [ + { + "bbox": [ + 106, + 572, + 504, + 583 + ], + "score": 1.0, + "content": "from a static dataset that is collected in an offline manner (Levine et al., 2020). While standard off-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 582, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 506, + 596 + ], + "score": 1.0, + "content": "policy RL algorithms (Mnih et al., 2013; Lillicrap et al., 2016; Haarnoja et al., 2018a) can, in theory,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "be employed to learn from an offline data, in practice, they perform poorly due to distributional shift", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 605, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 506, + 617 + ], + "score": 1.0, + "content": "between the behavior policy (probability distribution of actions conditioned on states as observed in", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 615, + 506, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 506, + 628 + ], + "score": 1.0, + "content": "the dataset) of the collected dataset and the learned policy (Levine et al., 2020). The distributional", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 626, + 506, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 506, + 639 + ], + "score": 1.0, + "content": "shift manifests itself in form of overestimation of the out-of-distribution (OOD) actions leading to", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 637, + 222, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 222, + 651 + ], + "score": 1.0, + "content": "erroneous Bellman backups.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 107, + 655, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "Prior works tackle this problem via behavior regularization (Fujimoto et al., 2018b; Kumar et al.,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 664, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 505, + 679 + ], + "score": 1.0, + "content": "2019; Wu et al., 2019; Siegel et al., 2020). This ensures that the learned policy stays “close” to the", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 450, + 690 + ], + "score": 1.0, + "content": "behavior policy. This is achieved by adding a regularization term that calculates the", + "type": "text" + }, + { + "bbox": [ + 450, + 677, + 457, + 689 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 676, + 505, + 690 + ], + "score": 1.0, + "content": "-divergence", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "between the learned policy and the behavior policy. Kernel Maximum Mean Discrepancy (MMD)", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "(Gretton et al., 2007), Wasserstein distance and KL divergence are widely used (Wu et al., 2019).", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "The regularization term is either fixed (Wu et al., 2019), or tuned via dual gradient descent (Kumar", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 720, + 403, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 403, + 734 + ], + "score": 1.0, + "content": "et al., 2019), or applied using a trust region objective (Siegel et al., 2020).", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 44 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 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 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 303, + 752, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "1", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 503, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 77, + 505, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 77, + 156, + 97 + ], + "score": 1.0, + "content": "BRAC", + "type": "text" + }, + { + "bbox": [ + 156, + 81, + 168, + 95 + ], + "score": 0.29, + "content": "+", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 77, + 505, + 97 + ], + "score": 1.0, + "content": ": GOING DEEPER WITH BEHAVIOR REGULAR-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 99, + 428, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 99, + 428, + 118 + ], + "score": 1.0, + "content": "IZED OFFLINE REINFORCEMENT LEARNING", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 113, + 136, + 244, + 157 + ], + "lines": [ + { + "bbox": [ + 113, + 136, + 201, + 147 + ], + "spans": [ + { + "bbox": [ + 113, + 136, + 201, + 147 + ], + "score": 1.0, + "content": "Anonymous authors", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 111, + 146, + 245, + 158 + ], + "spans": [ + { + "bbox": [ + 111, + 146, + 245, + 158 + ], + "score": 1.0, + "content": "Paper under double-blind review", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5, + "bbox_fs": [ + 111, + 136, + 245, + 158 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 186, + 333, + 199 + ], + "lines": [ + { + "bbox": [ + 276, + 186, + 335, + 200 + ], + "spans": [ + { + "bbox": [ + 276, + 186, + 335, + 200 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 143, + 211, + 468, + 453 + ], + "lines": [ + { + "bbox": [ + 141, + 210, + 470, + 225 + ], + "spans": [ + { + "bbox": [ + 141, + 210, + 470, + 225 + ], + "score": 1.0, + "content": "Online interactions with the environment to collect data samples for training a", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 223, + 469, + 235 + ], + "spans": [ + { + "bbox": [ + 141, + 223, + 469, + 235 + ], + "score": 1.0, + "content": "Reinforcement Learning agent is not always feasible due to economic and safety", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 233, + 469, + 246 + ], + "spans": [ + { + "bbox": [ + 141, + 233, + 469, + 246 + ], + "score": 1.0, + "content": "concerns. The goal of Offline Reinforcement Learning (RL) is to address this", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 142, + 245, + 469, + 257 + ], + "spans": [ + { + "bbox": [ + 142, + 245, + 469, + 257 + ], + "score": 1.0, + "content": "problem by learning effective policies using previously collected datasets. Stan-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 142, + 256, + 469, + 268 + ], + "spans": [ + { + "bbox": [ + 142, + 256, + 469, + 268 + ], + "score": 1.0, + "content": "dard off-policy RL algorithms are prone to overestimations of the values of out-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 142, + 267, + 469, + 279 + ], + "spans": [ + { + "bbox": [ + 142, + 267, + 469, + 279 + ], + "score": 1.0, + "content": "of-distribution (less explored) actions and are hence unsuitable for Offline RL.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 277, + 470, + 290 + ], + "spans": [ + { + "bbox": [ + 141, + 277, + 470, + 290 + ], + "score": 1.0, + "content": "Behavior regularization, which constraints the learned policy within the support", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 288, + 469, + 301 + ], + "spans": [ + { + "bbox": [ + 141, + 288, + 469, + 301 + ], + "score": 1.0, + "content": "set of the dataset, has been proposed to tackle the limitations of standard off-policy", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 142, + 300, + 469, + 311 + ], + "spans": [ + { + "bbox": [ + 142, + 300, + 469, + 311 + ], + "score": 1.0, + "content": "algorithms. In this paper, we improve the behavior regularized offline reinforce-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 311, + 469, + 322 + ], + "spans": [ + { + "bbox": [ + 141, + 311, + 255, + 322 + ], + "score": 1.0, + "content": "ment learning and propose", + "type": "text" + }, + { + "bbox": [ + 255, + 311, + 288, + 321 + ], + "score": 0.86, + "content": "B R A C +", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 311, + 469, + 322 + ], + "score": 1.0, + "content": ". We use an analytical upper bound on KL", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 142, + 322, + 469, + 334 + ], + "spans": [ + { + "bbox": [ + 142, + 322, + 469, + 334 + ], + "score": 1.0, + "content": "divergence as the behavior regularizor to reduce variance associated with sample", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 332, + 469, + 345 + ], + "spans": [ + { + "bbox": [ + 141, + 332, + 469, + 345 + ], + "score": 1.0, + "content": "based estimations. Additionally, we employ state-dependent Lagrange multipli-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 343, + 469, + 356 + ], + "spans": [ + { + "bbox": [ + 141, + 343, + 469, + 356 + ], + "score": 1.0, + "content": "ers for the regularization term to avoid distributing KL divergence penalty across", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 354, + 469, + 366 + ], + "spans": [ + { + "bbox": [ + 141, + 354, + 469, + 366 + ], + "score": 1.0, + "content": "all states of the sampled batch. The proposed Lagrange multipliers allow more", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 365, + 469, + 378 + ], + "spans": [ + { + "bbox": [ + 141, + 365, + 469, + 378 + ], + "score": 1.0, + "content": "freedom of deviation to high probability (more explored) states leading to better", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 377, + 469, + 388 + ], + "spans": [ + { + "bbox": [ + 141, + 377, + 469, + 388 + ], + "score": 1.0, + "content": "rewards while simultaneously restricting low probability (less explored) states to", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 141, + 387, + 469, + 399 + ], + "spans": [ + { + "bbox": [ + 141, + 387, + 469, + 399 + ], + "score": 1.0, + "content": "prevent out-of-distribution actions. To prevent catastrophic performance degra-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 398, + 469, + 410 + ], + "spans": [ + { + "bbox": [ + 141, + 398, + 469, + 410 + ], + "score": 1.0, + "content": "dation due to rare out-of-distribution actions, we add a gradient penalty term to", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 142, + 409, + 469, + 420 + ], + "spans": [ + { + "bbox": [ + 142, + 409, + 469, + 420 + ], + "score": 1.0, + "content": "the policy evaluation objective to penalize the gradient of the Q value w.r.t the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 141, + 420, + 469, + 432 + ], + "spans": [ + { + "bbox": [ + 141, + 420, + 469, + 432 + ], + "score": 1.0, + "content": "out-of-distribution actions. By doing so, the Q values evaluated at the out-of-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 142, + 430, + 469, + 442 + ], + "spans": [ + { + "bbox": [ + 142, + 430, + 434, + 442 + ], + "score": 1.0, + "content": "distribution actions are bounded. On challenging offline RL benchmarks,", + "type": "text" + }, + { + "bbox": [ + 434, + 431, + 469, + 442 + ], + "score": 0.37, + "content": "{ \\mathrm { B R A C } } +", + "type": "inline_equation" + } + ], + "index": 25 + }, + { + "bbox": [ + 141, + 441, + 436, + 455 + ], + "spans": [ + { + "bbox": [ + 141, + 441, + 436, + 455 + ], + "score": 1.0, + "content": "outperforms the state-of-the-art model-free and model-based approaches.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 15.5, + "bbox_fs": [ + 141, + 210, + 470, + 455 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 475, + 206, + 487 + ], + "lines": [ + { + "bbox": [ + 105, + 474, + 208, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 208, + 491 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 500, + 505, + 555 + ], + "lines": [ + { + "bbox": [ + 105, + 498, + 506, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 506, + 515 + ], + "score": 1.0, + "content": "Reinforcement Learning (RL) has shown great success in a wide range of applications including", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 510, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 505, + 524 + ], + "score": 1.0, + "content": "board games (Silver et al., 2016), strategy games (Vinyals et al., 2019), energy systems (Zhang", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 523, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 505, + 534 + ], + "score": 1.0, + "content": "et al., 2019), robotics (Lin, 1992), recommendation systems (Choi et al., 2018), etc. The success of", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "score": 1.0, + "content": "RL relies heavily on extensive online interactions with the environment for exploration. However,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 543, + 505, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 505, + 557 + ], + "score": 1.0, + "content": "this is not always feasible in the real world as it can be expensive or dangerous (Levine et al., 2020).", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30, + "bbox_fs": [ + 105, + 498, + 506, + 557 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 561, + 504, + 649 + ], + "lines": [ + { + "bbox": [ + 105, + 560, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 505, + 574 + ], + "score": 1.0, + "content": "Offline RL, also known as batch RL, avoids online interactions with the environment by learning", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 572, + 504, + 583 + ], + "spans": [ + { + "bbox": [ + 106, + 572, + 504, + 583 + ], + "score": 1.0, + "content": "from a static dataset that is collected in an offline manner (Levine et al., 2020). While standard off-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 582, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 506, + 596 + ], + "score": 1.0, + "content": "policy RL algorithms (Mnih et al., 2013; Lillicrap et al., 2016; Haarnoja et al., 2018a) can, in theory,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "be employed to learn from an offline data, in practice, they perform poorly due to distributional shift", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 605, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 506, + 617 + ], + "score": 1.0, + "content": "between the behavior policy (probability distribution of actions conditioned on states as observed in", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 615, + 506, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 506, + 628 + ], + "score": 1.0, + "content": "the dataset) of the collected dataset and the learned policy (Levine et al., 2020). The distributional", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 626, + 506, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 506, + 639 + ], + "score": 1.0, + "content": "shift manifests itself in form of overestimation of the out-of-distribution (OOD) actions leading to", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 637, + 222, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 222, + 651 + ], + "score": 1.0, + "content": "erroneous Bellman backups.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 560, + 506, + 651 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 655, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "Prior works tackle this problem via behavior regularization (Fujimoto et al., 2018b; Kumar et al.,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 664, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 505, + 679 + ], + "score": 1.0, + "content": "2019; Wu et al., 2019; Siegel et al., 2020). This ensures that the learned policy stays “close” to the", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 450, + 690 + ], + "score": 1.0, + "content": "behavior policy. This is achieved by adding a regularization term that calculates the", + "type": "text" + }, + { + "bbox": [ + 450, + 677, + 457, + 689 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 676, + 505, + 690 + ], + "score": 1.0, + "content": "-divergence", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "between the learned policy and the behavior policy. Kernel Maximum Mean Discrepancy (MMD)", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "(Gretton et al., 2007), Wasserstein distance and KL divergence are widely used (Wu et al., 2019).", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "The regularization term is either fixed (Wu et al., 2019), or tuned via dual gradient descent (Kumar", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 720, + 403, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 403, + 734 + ], + "score": 1.0, + "content": "et al., 2019), or applied using a trust region objective (Siegel et al., 2020).", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 44, + "bbox_fs": [ + 105, + 655, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 270 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "In this paper, we propose improvements to the Behavior Regularized Actor Critic (BRAC) algorithm", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 504, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 504, + 106 + ], + "score": 1.0, + "content": "presented in (Wu et al., 2019). To obtain the same, we observe that sample based estimation of di-", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "vergence measures is computationally expensive and prone to higher variance. Therefore, to reduce", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 115, + 504, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 504, + 127 + ], + "score": 1.0, + "content": "variance, we derive an analytical upper bound on the KL divergence measure as the regularization", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 127, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 106, + 127, + 505, + 138 + ], + "score": 1.0, + "content": "term in the objective function. Moreover, we show that current works that apply the regularization", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 138, + 505, + 149 + ], + "spans": [ + { + "bbox": [ + 106, + 138, + 505, + 149 + ], + "score": 1.0, + "content": "term i.e. the divergence measure, on the entire batch, end up distributing the penalty over all states", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 148, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 505, + 161 + ], + "score": 1.0, + "content": "in the batch in amounts inversely proportional to the state’s probability of occurrence in the batch.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 158, + 506, + 172 + ], + "spans": [ + { + "bbox": [ + 105, + 158, + 506, + 172 + ], + "score": 1.0, + "content": "This needlessly restricts the deviation of highly explored states while allowing less explored ones to", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 169, + 506, + 183 + ], + "spans": [ + { + "bbox": [ + 105, + 169, + 506, + 183 + ], + "score": 1.0, + "content": "deviate farther leading to OOD actions. To address the same, we employ state dependent Lagrange", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 181, + 505, + 193 + ], + "spans": [ + { + "bbox": [ + 106, + 181, + 505, + 193 + ], + "score": 1.0, + "content": "multipliers for the regularization terms and automatically tune their strength using state-wise dual", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "score": 1.0, + "content": "gradient descent. In addition, the performance of the learned agent trained using prior methods", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 203, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 203, + 505, + 216 + ], + "score": 1.0, + "content": "often deteriorates over the course of training. We found that if the learned Q function generalizes", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 213, + 506, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 213, + 506, + 227 + ], + "score": 1.0, + "content": "such that the gradient of the Q function w.r.t the OOD actions is monotonically increasing, behavior", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 225, + 505, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 505, + 237 + ], + "score": 1.0, + "content": "regularization fails to keep such actions within the support set. To mitigate this issue, we penalize", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 235, + 505, + 248 + ], + "spans": [ + { + "bbox": [ + 106, + 235, + 505, + 248 + ], + "score": 1.0, + "content": "the gradient of the Q function w.r.t the OOD actions by adding a gradient penalty term to the pol-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 246, + 506, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 506, + 259 + ], + "score": 1.0, + "content": "icy evaluation objective. This reduces the policy improvement at OOD actions to the problem of", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 256, + 423, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 256, + 423, + 271 + ], + "score": 1.0, + "content": "minimizing the divergence between the learned policy and the behavior policy.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 108, + 275, + 505, + 308 + ], + "lines": [ + { + "bbox": [ + 106, + 273, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 236, + 288 + ], + "score": 1.0, + "content": "We call our improved algorithm", + "type": "text" + }, + { + "bbox": [ + 237, + 275, + 271, + 285 + ], + "score": 0.42, + "content": "{ \\mathrm { B R A C } } +", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 273, + 505, + 288 + ], + "score": 1.0, + "content": "following (Wu et al., 2019). Our experiments suggest that", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 286, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 106, + 286, + 141, + 297 + ], + "score": 0.34, + "content": "{ \\mathrm { B R A C } } +", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 286, + 505, + 298 + ], + "score": 1.0, + "content": "outperforms existing state-of-the-art model-free and model-based offline RL algorithms in", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 107, + 297, + 342, + 308 + ], + "spans": [ + { + "bbox": [ + 107, + 297, + 342, + 308 + ], + "score": 1.0, + "content": "various datasets on the D4RL benchmark (Fu et al., 2020).", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "title", + "bbox": [ + 108, + 324, + 200, + 336 + ], + "lines": [ + { + "bbox": [ + 104, + 322, + 202, + 340 + ], + "spans": [ + { + "bbox": [ + 104, + 322, + 202, + 340 + ], + "score": 1.0, + "content": "2 BACKGROUND", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 106, + 348, + 505, + 427 + ], + "lines": [ + { + "bbox": [ + 105, + 348, + 505, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 505, + 361 + ], + "score": 1.0, + "content": "Markov Decision Process RL algorithms aim to solve Markov Decision Process (MDP) with", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 360, + 505, + 372 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 495, + 372 + ], + "score": 1.0, + "content": "unknown dynamics. A Markov decision process (Sutton & Barto, 2018) is defined as a tuple", + "type": "text" + }, + { + "bbox": [ + 495, + 361, + 505, + 371 + ], + "score": 0.75, + "content": "<", + "type": "inline_equation" + } + ], + "index": 22 + }, + { + "bbox": [ + 107, + 371, + 504, + 383 + ], + "spans": [ + { + "bbox": [ + 107, + 371, + 171, + 383 + ], + "score": 0.92, + "content": "{ \\mathcal { S } } , { \\mathcal { A } } , R , P , \\mu >", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 371, + 202, + 383 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 203, + 372, + 211, + 381 + ], + "score": 0.8, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 371, + 289, + 383 + ], + "score": 1.0, + "content": "is the set of states,", + "type": "text" + }, + { + "bbox": [ + 289, + 372, + 298, + 381 + ], + "score": 0.79, + "content": "\\mathcal { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 371, + 382, + 383 + ], + "score": 1.0, + "content": "is the set of actions,", + "type": "text" + }, + { + "bbox": [ + 383, + 371, + 504, + 383 + ], + "score": 0.9, + "content": "R ( s , a , s ^ { \\prime } ) : \\mathcal { S } \\times \\mathcal { A } \\times \\mathcal { S } \\mathbb { R }", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 381, + 506, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 394, + 395 + ], + "score": 1.0, + "content": "defines the intermediate reward when the agent transitions from state", + "type": "text" + }, + { + "bbox": [ + 394, + 384, + 401, + 392 + ], + "score": 0.73, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 381, + 414, + 395 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 414, + 383, + 423, + 392 + ], + "score": 0.82, + "content": "s ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 381, + 495, + 395 + ], + "score": 1.0, + "content": "by taking action", + "type": "text" + }, + { + "bbox": [ + 495, + 385, + 501, + 392 + ], + "score": 0.61, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 381, + 506, + 395 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 107, + 393, + 504, + 406 + ], + "spans": [ + { + "bbox": [ + 107, + 393, + 247, + 405 + ], + "score": 0.92, + "content": "P ( s ^ { \\prime } | s , a ) : \\mathcal { S } \\times \\mathcal { A } \\times \\mathcal { S } \\to [ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 247, + 393, + 498, + 406 + ], + "score": 1.0, + "content": "defines the probability when the agent transitions from state", + "type": "text" + }, + { + "bbox": [ + 498, + 396, + 504, + 403 + ], + "score": 0.69, + "content": "s", + "type": "inline_equation" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 404, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 106, + 404, + 118, + 416 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 118, + 405, + 126, + 414 + ], + "score": 0.82, + "content": "s ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 404, + 199, + 416 + ], + "score": 1.0, + "content": "by taking action", + "type": "text" + }, + { + "bbox": [ + 199, + 407, + 205, + 414 + ], + "score": 0.46, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 404, + 210, + 416 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 211, + 404, + 276, + 416 + ], + "score": 0.89, + "content": "\\mu : { \\dot { \\mathcal { S } } } \\ { \\dot { } } \\ [ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 404, + 505, + 416 + ], + "score": 1.0, + "content": "defines the starting state distribution. The objective of", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 415, + 482, + 428 + ], + "spans": [ + { + "bbox": [ + 106, + 415, + 272, + 428 + ], + "score": 1.0, + "content": "reinforcement learning is to select policy", + "type": "text" + }, + { + "bbox": [ + 272, + 415, + 332, + 427 + ], + "score": 0.93, + "content": "{ \\dot { \\pi } } : \\mu \\to P ( A )", + "type": "inline_equation" + }, + { + "bbox": [ + 332, + 415, + 482, + 428 + ], + "score": 1.0, + "content": "to maximize the following objective:", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24 + }, + { + "type": "interline_equation", + "bbox": [ + 213, + 432, + 398, + 469 + ], + "lines": [ + { + "bbox": [ + 213, + 432, + 398, + 469 + ], + "spans": [ + { + "bbox": [ + 213, + 432, + 398, + 469 + ], + "score": 0.94, + "content": "J ( \\pi ) = \\underset { s _ { 0 } \\sim \\mu , a _ { t } \\sim \\pi ( \\cdot | s _ { t } ) } { \\mathbb { E } } [ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } R ( s _ { t } , a _ { t } , s _ { t + 1 } ) ]", + "type": "interline_equation", + "image_path": "f19dc9a3e1b9ae15ef135390927c29082d3cea38d1df43b0c252b7cb7e077397.jpg" + } + ] + } + ], + "index": 28.5, + "virtual_lines": [ + { + "bbox": [ + 213, + 432, + 398, + 450.5 + ], + "spans": [], + "index": 28 + }, + { + "bbox": [ + 213, + 450.5, + 398, + 469.0 + ], + "spans": [], + "index": 29 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 478, + 505, + 558 + ], + "lines": [ + { + "bbox": [ + 105, + 478, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 412, + 492 + ], + "score": 1.0, + "content": "Offline Reinforcement Learning The goal of offline RL is to learn policy", + "type": "text" + }, + { + "bbox": [ + 412, + 482, + 423, + 491 + ], + "score": 0.84, + "content": "\\pi _ { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 478, + 506, + 492 + ], + "score": 1.0, + "content": "from a fixed dataset", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 486, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 106, + 490, + 210, + 503 + ], + "score": 0.91, + "content": "\\mathcal { D } = \\{ ( s _ { i } , a _ { i } , s ^ { \\prime } { } _ { i } , r _ { i } ) \\} _ { i = 1 } ^ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 486, + 358, + 509 + ], + "score": 1.0, + "content": "consisting of single step transitions", + "type": "text" + }, + { + "bbox": [ + 359, + 491, + 426, + 503 + ], + "score": 0.92, + "content": "\\left\\{ \\left( s _ { i } , a _ { i } , s ^ { \\prime } _ { i } , r _ { i } \\right) \\right\\}", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 486, + 506, + 509 + ], + "score": 1.0, + "content": ". The dataset is as-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 501, + 504, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 292, + 514 + ], + "score": 1.0, + "content": "sumed to be collected using a behavior policy", + "type": "text" + }, + { + "bbox": [ + 293, + 503, + 305, + 514 + ], + "score": 0.87, + "content": "\\pi _ { \\beta }", + "type": "inline_equation" + }, + { + "bbox": [ + 305, + 501, + 477, + 514 + ], + "score": 1.0, + "content": "which denotes the conditional distribution", + "type": "text" + }, + { + "bbox": [ + 477, + 502, + 504, + 514 + ], + "score": 0.92, + "content": "p ( a | s )", + "type": "inline_equation" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 245, + 525 + ], + "score": 1.0, + "content": "observed in the dataset. Note that", + "type": "text" + }, + { + "bbox": [ + 245, + 514, + 257, + 525 + ], + "score": 0.86, + "content": "\\pi _ { \\beta }", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 512, + 505, + 525 + ], + "score": 1.0, + "content": "may consist of multi-modal policy distribution. In principle,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 523, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 505, + 536 + ], + "score": 1.0, + "content": "standard off-policy RL algorithms using a replay buffer (Mnih et al., 2013; Lillicrap et al., 2016;", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 534, + 504, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 291, + 547 + ], + "score": 1.0, + "content": "Haarnoja et al., 2018a) can directly learn from", + "type": "text" + }, + { + "bbox": [ + 292, + 535, + 301, + 545 + ], + "score": 0.77, + "content": "\\mathcal { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 301, + 534, + 504, + 547 + ], + "score": 1.0, + "content": ". The key challenge resides in the policy evaluation", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 545, + 129, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 545, + 129, + 560 + ], + "score": 1.0, + "content": "step:", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 33 + }, + { + "type": "interline_equation", + "bbox": [ + 131, + 561, + 480, + 584 + ], + "lines": [ + { + "bbox": [ + 131, + 561, + 480, + 584 + ], + "spans": [ + { + "bbox": [ + 131, + 561, + 480, + 584 + ], + "score": 0.89, + "content": "Q _ { \\psi } = \\arg \\operatorname* { m i n } _ { \\psi } [ ( Q _ { \\psi } ( s , a ) - ( r ( s , a ) + \\gamma \\mathbb { E } _ { a ^ { \\prime } \\sim \\pi _ { \\theta } } Q _ { \\psi ^ { \\prime } } ( s ^ { \\prime } , a ^ { \\prime } ) ) ) ] ^ { 2 } \\qquad \\mathrm { ( p o l i c y ~ e v a l u a t i o n ) }", + "type": "interline_equation", + "image_path": "b31a9b235e06cf7dca169aaec0f533d273e7f89f396c64137cbe02f78323eb02.jpg" + } + ] + } + ], + "index": 37, + "virtual_lines": [ + { + "bbox": [ + 131, + 561, + 480, + 584 + ], + "spans": [], + "index": 37 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 587, + 505, + 655 + ], + "lines": [ + { + "bbox": [ + 105, + 587, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 200, + 601 + ], + "score": 1.0, + "content": "In this step, the target", + "type": "text" + }, + { + "bbox": [ + 201, + 588, + 210, + 600 + ], + "score": 0.54, + "content": "\\mathrm { Q }", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 587, + 505, + 601 + ], + "score": 1.0, + "content": "value depends on the learned policy. If the learned policy distribution", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 600, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 106, + 601, + 118, + 610 + ], + "score": 0.8, + "content": "\\pi _ { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 118, + 600, + 267, + 612 + ], + "score": 1.0, + "content": "diverges from the data distribution", + "type": "text" + }, + { + "bbox": [ + 267, + 601, + 280, + 612 + ], + "score": 0.86, + "content": "\\pi _ { \\beta }", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 600, + 505, + 612 + ], + "score": 1.0, + "content": ", it results in evaluation of target Q values using out-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 610, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 505, + 623 + ], + "score": 1.0, + "content": "of-distribution (OOD) actions. Such evaluations are prone to errors. Erroneous overestimation", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 621, + 505, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 505, + 634 + ], + "score": 1.0, + "content": "of values get exploited by the policy improvement, preventing the algorithm from learning useful", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 632, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 505, + 645 + ], + "score": 1.0, + "content": "policies. In order to avoid such cases, behavior regularization is adopted to force the learned policy", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 642, + 502, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 642, + 502, + 655 + ], + "score": 1.0, + "content": "to stay “close” to the behavior policy (Fujimoto et al., 2018b; Kumar et al., 2019; Wu et al., 2019).", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 40.5 + }, + { + "type": "title", + "bbox": [ + 108, + 670, + 460, + 697 + ], + "lines": [ + { + "bbox": [ + 104, + 669, + 462, + 685 + ], + "spans": [ + { + "bbox": [ + 104, + 669, + 462, + 685 + ], + "score": 1.0, + "content": "3 IMPROVING BEHAVIOR REGULARIZED OFFLINE REINFORCEMENT", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 124, + 685, + 183, + 698 + ], + "spans": [ + { + "bbox": [ + 124, + 685, + 183, + 698 + ], + "score": 1.0, + "content": "LEARNING", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 710, + 504, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 504, + 721 + ], + "score": 1.0, + "content": "In this section, we discuss and propose three non-trivial improvements to the Behavior Regularized", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 721, + 504, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 504, + 732 + ], + "score": 1.0, + "content": "Actor Critic (BRAC) offline reinforcement learning (Wu et al., 2019). BRAC (Wu et al., 2019)", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 46.5 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 306, + 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 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "score": 1.0, + "content": "2", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 270 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "In this paper, we propose improvements to the Behavior Regularized Actor Critic (BRAC) algorithm", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 504, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 504, + 106 + ], + "score": 1.0, + "content": "presented in (Wu et al., 2019). To obtain the same, we observe that sample based estimation of di-", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "vergence measures is computationally expensive and prone to higher variance. Therefore, to reduce", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 115, + 504, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 504, + 127 + ], + "score": 1.0, + "content": "variance, we derive an analytical upper bound on the KL divergence measure as the regularization", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 127, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 106, + 127, + 505, + 138 + ], + "score": 1.0, + "content": "term in the objective function. Moreover, we show that current works that apply the regularization", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 138, + 505, + 149 + ], + "spans": [ + { + "bbox": [ + 106, + 138, + 505, + 149 + ], + "score": 1.0, + "content": "term i.e. the divergence measure, on the entire batch, end up distributing the penalty over all states", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 148, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 505, + 161 + ], + "score": 1.0, + "content": "in the batch in amounts inversely proportional to the state’s probability of occurrence in the batch.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 158, + 506, + 172 + ], + "spans": [ + { + "bbox": [ + 105, + 158, + 506, + 172 + ], + "score": 1.0, + "content": "This needlessly restricts the deviation of highly explored states while allowing less explored ones to", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 169, + 506, + 183 + ], + "spans": [ + { + "bbox": [ + 105, + 169, + 506, + 183 + ], + "score": 1.0, + "content": "deviate farther leading to OOD actions. To address the same, we employ state dependent Lagrange", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 181, + 505, + 193 + ], + "spans": [ + { + "bbox": [ + 106, + 181, + 505, + 193 + ], + "score": 1.0, + "content": "multipliers for the regularization terms and automatically tune their strength using state-wise dual", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "score": 1.0, + "content": "gradient descent. In addition, the performance of the learned agent trained using prior methods", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 203, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 203, + 505, + 216 + ], + "score": 1.0, + "content": "often deteriorates over the course of training. We found that if the learned Q function generalizes", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 213, + 506, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 213, + 506, + 227 + ], + "score": 1.0, + "content": "such that the gradient of the Q function w.r.t the OOD actions is monotonically increasing, behavior", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 225, + 505, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 505, + 237 + ], + "score": 1.0, + "content": "regularization fails to keep such actions within the support set. To mitigate this issue, we penalize", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 235, + 505, + 248 + ], + "spans": [ + { + "bbox": [ + 106, + 235, + 505, + 248 + ], + "score": 1.0, + "content": "the gradient of the Q function w.r.t the OOD actions by adding a gradient penalty term to the pol-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 246, + 506, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 506, + 259 + ], + "score": 1.0, + "content": "icy evaluation objective. This reduces the policy improvement at OOD actions to the problem of", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 256, + 423, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 256, + 423, + 271 + ], + "score": 1.0, + "content": "minimizing the divergence between the learned policy and the behavior policy.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 82, + 506, + 271 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 275, + 505, + 308 + ], + "lines": [ + { + "bbox": [ + 106, + 273, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 236, + 288 + ], + "score": 1.0, + "content": "We call our improved algorithm", + "type": "text" + }, + { + "bbox": [ + 237, + 275, + 271, + 285 + ], + "score": 0.42, + "content": "{ \\mathrm { B R A C } } +", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 273, + 505, + 288 + ], + "score": 1.0, + "content": "following (Wu et al., 2019). Our experiments suggest that", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 286, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 106, + 286, + 141, + 297 + ], + "score": 0.34, + "content": "{ \\mathrm { B R A C } } +", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 286, + 505, + 298 + ], + "score": 1.0, + "content": "outperforms existing state-of-the-art model-free and model-based offline RL algorithms in", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 107, + 297, + 342, + 308 + ], + "spans": [ + { + "bbox": [ + 107, + 297, + 342, + 308 + ], + "score": 1.0, + "content": "various datasets on the D4RL benchmark (Fu et al., 2020).", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 106, + 273, + 505, + 308 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 324, + 200, + 336 + ], + "lines": [ + { + "bbox": [ + 104, + 322, + 202, + 340 + ], + "spans": [ + { + "bbox": [ + 104, + 322, + 202, + 340 + ], + "score": 1.0, + "content": "2 BACKGROUND", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 106, + 348, + 505, + 427 + ], + "lines": [ + { + "bbox": [ + 105, + 348, + 505, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 505, + 361 + ], + "score": 1.0, + "content": "Markov Decision Process RL algorithms aim to solve Markov Decision Process (MDP) with", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 360, + 505, + 372 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 495, + 372 + ], + "score": 1.0, + "content": "unknown dynamics. A Markov decision process (Sutton & Barto, 2018) is defined as a tuple", + "type": "text" + }, + { + "bbox": [ + 495, + 361, + 505, + 371 + ], + "score": 0.75, + "content": "<", + "type": "inline_equation" + } + ], + "index": 22 + }, + { + "bbox": [ + 107, + 371, + 504, + 383 + ], + "spans": [ + { + "bbox": [ + 107, + 371, + 171, + 383 + ], + "score": 0.92, + "content": "{ \\mathcal { S } } , { \\mathcal { A } } , R , P , \\mu >", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 371, + 202, + 383 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 203, + 372, + 211, + 381 + ], + "score": 0.8, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 371, + 289, + 383 + ], + "score": 1.0, + "content": "is the set of states,", + "type": "text" + }, + { + "bbox": [ + 289, + 372, + 298, + 381 + ], + "score": 0.79, + "content": "\\mathcal { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 371, + 382, + 383 + ], + "score": 1.0, + "content": "is the set of actions,", + "type": "text" + }, + { + "bbox": [ + 383, + 371, + 504, + 383 + ], + "score": 0.9, + "content": "R ( s , a , s ^ { \\prime } ) : \\mathcal { S } \\times \\mathcal { A } \\times \\mathcal { S } \\mathbb { R }", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 381, + 506, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 394, + 395 + ], + "score": 1.0, + "content": "defines the intermediate reward when the agent transitions from state", + "type": "text" + }, + { + "bbox": [ + 394, + 384, + 401, + 392 + ], + "score": 0.73, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 381, + 414, + 395 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 414, + 383, + 423, + 392 + ], + "score": 0.82, + "content": "s ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 381, + 495, + 395 + ], + "score": 1.0, + "content": "by taking action", + "type": "text" + }, + { + "bbox": [ + 495, + 385, + 501, + 392 + ], + "score": 0.61, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 381, + 506, + 395 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 107, + 393, + 504, + 406 + ], + "spans": [ + { + "bbox": [ + 107, + 393, + 247, + 405 + ], + "score": 0.92, + "content": "P ( s ^ { \\prime } | s , a ) : \\mathcal { S } \\times \\mathcal { A } \\times \\mathcal { S } \\to [ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 247, + 393, + 498, + 406 + ], + "score": 1.0, + "content": "defines the probability when the agent transitions from state", + "type": "text" + }, + { + "bbox": [ + 498, + 396, + 504, + 403 + ], + "score": 0.69, + "content": "s", + "type": "inline_equation" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 404, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 106, + 404, + 118, + 416 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 118, + 405, + 126, + 414 + ], + "score": 0.82, + "content": "s ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 404, + 199, + 416 + ], + "score": 1.0, + "content": "by taking action", + "type": "text" + }, + { + "bbox": [ + 199, + 407, + 205, + 414 + ], + "score": 0.46, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 404, + 210, + 416 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 211, + 404, + 276, + 416 + ], + "score": 0.89, + "content": "\\mu : { \\dot { \\mathcal { S } } } \\ { \\dot { } } \\ [ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 404, + 505, + 416 + ], + "score": 1.0, + "content": "defines the starting state distribution. The objective of", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 415, + 482, + 428 + ], + "spans": [ + { + "bbox": [ + 106, + 415, + 272, + 428 + ], + "score": 1.0, + "content": "reinforcement learning is to select policy", + "type": "text" + }, + { + "bbox": [ + 272, + 415, + 332, + 427 + ], + "score": 0.93, + "content": "{ \\dot { \\pi } } : \\mu \\to P ( A )", + "type": "inline_equation" + }, + { + "bbox": [ + 332, + 415, + 482, + 428 + ], + "score": 1.0, + "content": "to maximize the following objective:", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24, + "bbox_fs": [ + 105, + 348, + 506, + 428 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 213, + 432, + 398, + 469 + ], + "lines": [ + { + "bbox": [ + 213, + 432, + 398, + 469 + ], + "spans": [ + { + "bbox": [ + 213, + 432, + 398, + 469 + ], + "score": 0.94, + "content": "J ( \\pi ) = \\underset { s _ { 0 } \\sim \\mu , a _ { t } \\sim \\pi ( \\cdot | s _ { t } ) } { \\mathbb { E } } [ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } R ( s _ { t } , a _ { t } , s _ { t + 1 } ) ]", + "type": "interline_equation", + "image_path": "f19dc9a3e1b9ae15ef135390927c29082d3cea38d1df43b0c252b7cb7e077397.jpg" + } + ] + } + ], + "index": 28.5, + "virtual_lines": [ + { + "bbox": [ + 213, + 432, + 398, + 450.5 + ], + "spans": [], + "index": 28 + }, + { + "bbox": [ + 213, + 450.5, + 398, + 469.0 + ], + "spans": [], + "index": 29 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 478, + 505, + 558 + ], + "lines": [ + { + "bbox": [ + 105, + 478, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 412, + 492 + ], + "score": 1.0, + "content": "Offline Reinforcement Learning The goal of offline RL is to learn policy", + "type": "text" + }, + { + "bbox": [ + 412, + 482, + 423, + 491 + ], + "score": 0.84, + "content": "\\pi _ { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 478, + 506, + 492 + ], + "score": 1.0, + "content": "from a fixed dataset", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 486, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 106, + 490, + 210, + 503 + ], + "score": 0.91, + "content": "\\mathcal { D } = \\{ ( s _ { i } , a _ { i } , s ^ { \\prime } { } _ { i } , r _ { i } ) \\} _ { i = 1 } ^ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 486, + 358, + 509 + ], + "score": 1.0, + "content": "consisting of single step transitions", + "type": "text" + }, + { + "bbox": [ + 359, + 491, + 426, + 503 + ], + "score": 0.92, + "content": "\\left\\{ \\left( s _ { i } , a _ { i } , s ^ { \\prime } _ { i } , r _ { i } \\right) \\right\\}", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 486, + 506, + 509 + ], + "score": 1.0, + "content": ". The dataset is as-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 501, + 504, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 292, + 514 + ], + "score": 1.0, + "content": "sumed to be collected using a behavior policy", + "type": "text" + }, + { + "bbox": [ + 293, + 503, + 305, + 514 + ], + "score": 0.87, + "content": "\\pi _ { \\beta }", + "type": "inline_equation" + }, + { + "bbox": [ + 305, + 501, + 477, + 514 + ], + "score": 1.0, + "content": "which denotes the conditional distribution", + "type": "text" + }, + { + "bbox": [ + 477, + 502, + 504, + 514 + ], + "score": 0.92, + "content": "p ( a | s )", + "type": "inline_equation" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 245, + 525 + ], + "score": 1.0, + "content": "observed in the dataset. Note that", + "type": "text" + }, + { + "bbox": [ + 245, + 514, + 257, + 525 + ], + "score": 0.86, + "content": "\\pi _ { \\beta }", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 512, + 505, + 525 + ], + "score": 1.0, + "content": "may consist of multi-modal policy distribution. In principle,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 523, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 505, + 536 + ], + "score": 1.0, + "content": "standard off-policy RL algorithms using a replay buffer (Mnih et al., 2013; Lillicrap et al., 2016;", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 534, + 504, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 291, + 547 + ], + "score": 1.0, + "content": "Haarnoja et al., 2018a) can directly learn from", + "type": "text" + }, + { + "bbox": [ + 292, + 535, + 301, + 545 + ], + "score": 0.77, + "content": "\\mathcal { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 301, + 534, + 504, + 547 + ], + "score": 1.0, + "content": ". The key challenge resides in the policy evaluation", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 545, + 129, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 545, + 129, + 560 + ], + "score": 1.0, + "content": "step:", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 33, + "bbox_fs": [ + 105, + 478, + 506, + 560 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 131, + 561, + 480, + 584 + ], + "lines": [ + { + "bbox": [ + 131, + 561, + 480, + 584 + ], + "spans": [ + { + "bbox": [ + 131, + 561, + 480, + 584 + ], + "score": 0.89, + "content": "Q _ { \\psi } = \\arg \\operatorname* { m i n } _ { \\psi } [ ( Q _ { \\psi } ( s , a ) - ( r ( s , a ) + \\gamma \\mathbb { E } _ { a ^ { \\prime } \\sim \\pi _ { \\theta } } Q _ { \\psi ^ { \\prime } } ( s ^ { \\prime } , a ^ { \\prime } ) ) ) ] ^ { 2 } \\qquad \\mathrm { ( p o l i c y ~ e v a l u a t i o n ) }", + "type": "interline_equation", + "image_path": "b31a9b235e06cf7dca169aaec0f533d273e7f89f396c64137cbe02f78323eb02.jpg" + } + ] + } + ], + "index": 37, + "virtual_lines": [ + { + "bbox": [ + 131, + 561, + 480, + 584 + ], + "spans": [], + "index": 37 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 587, + 505, + 655 + ], + "lines": [ + { + "bbox": [ + 105, + 587, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 200, + 601 + ], + "score": 1.0, + "content": "In this step, the target", + "type": "text" + }, + { + "bbox": [ + 201, + 588, + 210, + 600 + ], + "score": 0.54, + "content": "\\mathrm { Q }", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 587, + 505, + 601 + ], + "score": 1.0, + "content": "value depends on the learned policy. If the learned policy distribution", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 600, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 106, + 601, + 118, + 610 + ], + "score": 0.8, + "content": "\\pi _ { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 118, + 600, + 267, + 612 + ], + "score": 1.0, + "content": "diverges from the data distribution", + "type": "text" + }, + { + "bbox": [ + 267, + 601, + 280, + 612 + ], + "score": 0.86, + "content": "\\pi _ { \\beta }", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 600, + 505, + 612 + ], + "score": 1.0, + "content": ", it results in evaluation of target Q values using out-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 610, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 505, + 623 + ], + "score": 1.0, + "content": "of-distribution (OOD) actions. Such evaluations are prone to errors. Erroneous overestimation", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 621, + 505, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 505, + 634 + ], + "score": 1.0, + "content": "of values get exploited by the policy improvement, preventing the algorithm from learning useful", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 632, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 505, + 645 + ], + "score": 1.0, + "content": "policies. In order to avoid such cases, behavior regularization is adopted to force the learned policy", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 642, + 502, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 642, + 502, + 655 + ], + "score": 1.0, + "content": "to stay “close” to the behavior policy (Fujimoto et al., 2018b; Kumar et al., 2019; Wu et al., 2019).", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 40.5, + "bbox_fs": [ + 105, + 587, + 505, + 655 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 670, + 460, + 697 + ], + "lines": [ + { + "bbox": [ + 104, + 669, + 462, + 685 + ], + "spans": [ + { + "bbox": [ + 104, + 669, + 462, + 685 + ], + "score": 1.0, + "content": "3 IMPROVING BEHAVIOR REGULARIZED OFFLINE REINFORCEMENT", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 124, + 685, + 183, + 698 + ], + "spans": [ + { + "bbox": [ + 124, + 685, + 183, + 698 + ], + "score": 1.0, + "content": "LEARNING", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 710, + 504, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 504, + 721 + ], + "score": 1.0, + "content": "In this section, we discuss and propose three non-trivial improvements to the Behavior Regularized", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 721, + 504, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 504, + 732 + ], + "score": 1.0, + "content": "Actor Critic (BRAC) offline reinforcement learning (Wu et al., 2019). BRAC (Wu et al., 2019)", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 46.5, + "bbox_fs": [ + 106, + 710, + 504, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 505, + 117 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "augments either the policy improvement or the policy evaluation step with a penalty term to constrain", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 92, + 505, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 92, + 505, + 108 + ], + "score": 1.0, + "content": "the policy within the support set of the behavior policy. For simplicity of illustration, we only", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 105, + 330, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 330, + 117 + ], + "score": 1.0, + "content": "consider the policy improvement step (Wu et al., 2019):", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "interline_equation", + "bbox": [ + 171, + 134, + 439, + 155 + ], + "lines": [ + { + "bbox": [ + 171, + 134, + 439, + 155 + ], + "spans": [ + { + "bbox": [ + 171, + 134, + 439, + 155 + ], + "score": 0.89, + "content": "\\operatorname* { m a x } _ { \\pi _ { \\theta } } \\mathbb { E } _ { ( s , a , r , s ^ { \\prime } ) \\sim \\mathcal { D } } [ \\mathbb { E } _ { a ^ { \\prime \\prime } \\sim \\pi _ { \\theta } ( \\cdot \\vert s ) } [ Q _ { \\psi } ( s , a ^ { \\prime \\prime } ) ] - \\alpha \\hat { D } ( \\pi _ { \\theta } ( \\cdot \\vert s ) , \\pi _ { \\beta } ( \\cdot \\vert s ) ) ]", + "type": "interline_equation", + "image_path": "4b9148b79c78a204a759e2b24f047ee67bef674059b7d9c6ece703b049614d5a.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 171, + 134, + 439, + 155 + ], + "spans": [], + "index": 3 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 166, + 504, + 189 + ], + "lines": [ + { + "bbox": [ + 105, + 164, + 504, + 180 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 130, + 180 + ], + "score": 1.0, + "content": "Here,", + "type": "text" + }, + { + "bbox": [ + 131, + 165, + 140, + 177 + ], + "score": 0.86, + "content": "\\hat { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 164, + 191, + 180 + ], + "score": 1.0, + "content": "is a selected", + "type": "text" + }, + { + "bbox": [ + 191, + 167, + 198, + 178 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 199, + 164, + 504, + 180 + ], + "score": 1.0, + "content": "-divergence (Csiszar, 1972) measure used for behavior regularization. Zoom-´", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 177, + 267, + 191 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 267, + 191 + ], + "score": 1.0, + "content": "ing into the regularization term, we get:", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "interline_equation", + "bbox": [ + 244, + 192, + 366, + 219 + ], + "lines": [ + { + "bbox": [ + 244, + 192, + 366, + 219 + ], + "spans": [ + { + "bbox": [ + 244, + 192, + 366, + 219 + ], + "score": 0.94, + "content": "\\sum _ { s \\in S } ( P _ { s } \\alpha ) \\hat { D } ( \\pi _ { \\theta } ( \\cdot | s ) , \\pi _ { \\beta } ( \\cdot | s ) )", + "type": "interline_equation", + "image_path": "7a84cd86b7d50b3721174e1289d32cd24fa78f7aa8b5863bc3d92cb09c530362.jpg" + } + ] + } + ], + "index": 6.5, + "virtual_lines": [ + { + "bbox": [ + 244, + 192, + 366, + 205.5 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 244, + 205.5, + 366, + 219.0 + ], + "spans": [], + "index": 7 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 227, + 505, + 340 + ], + "lines": [ + { + "bbox": [ + 105, + 227, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 105, + 227, + 203, + 241 + ], + "score": 1.0, + "content": "In the equation above,", + "type": "text" + }, + { + "bbox": [ + 203, + 228, + 212, + 238 + ], + "score": 0.79, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 227, + 465, + 241 + ], + "score": 1.0, + "content": "denotes the states that occur in a single sampled batch and", + "type": "text" + }, + { + "bbox": [ + 465, + 228, + 477, + 239 + ], + "score": 0.89, + "content": "P _ { s }", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 227, + 505, + 241 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 239, + 506, + 253 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 184, + 253 + ], + "score": 1.0, + "content": "probability of state", + "type": "text" + }, + { + "bbox": [ + 184, + 241, + 190, + 249 + ], + "score": 0.74, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 239, + 506, + 253 + ], + "score": 1.0, + "content": "in the sampled batch. The first two improvements that we propose are targeted", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 104, + 249, + 504, + 266 + ], + "spans": [ + { + "bbox": [ + 104, + 249, + 397, + 266 + ], + "score": 1.0, + "content": "towards the following two terms in Equation 4: (1) The divergence term", + "type": "text" + }, + { + "bbox": [ + 397, + 250, + 407, + 262 + ], + "score": 0.86, + "content": "\\hat { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 249, + 492, + 266 + ], + "score": 1.0, + "content": "which for each fixed", + "type": "text" + }, + { + "bbox": [ + 492, + 253, + 504, + 263 + ], + "score": 0.82, + "content": "\\pi _ { \\theta }", + "type": "inline_equation" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 263, + 505, + 275 + ], + "spans": [ + { + "bbox": [ + 106, + 263, + 505, + 275 + ], + "score": 1.0, + "content": "determines the impact actions have on the overall objective conditional on the state, and (2) the term", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 107, + 273, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 107, + 273, + 132, + 286 + ], + "score": 0.91, + "content": "( P _ { s } \\alpha )", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 273, + 505, + 286 + ], + "score": 1.0, + "content": "which determines the impact the “divergence penalty” of each state will have on the overall", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 284, + 505, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 505, + 297 + ], + "score": 1.0, + "content": "objective function. Note that this term is dependent upon the probability of the occurrence of state in", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 294, + 505, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 505, + 309 + ], + "score": 1.0, + "content": "the sampled batch. For (1), we propose to use an analytical upper bound of KL divergence to reduce", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 307, + 505, + 320 + ], + "spans": [ + { + "bbox": [ + 106, + 307, + 505, + 320 + ], + "score": 1.0, + "content": "variance. For (2), we propose to decouple the impact of “divergence penalty” of each state from", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 318, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 318, + 505, + 331 + ], + "score": 1.0, + "content": "the probability of its occurrence. Detailed explanation of the two improvements and the rationale", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 328, + 306, + 341 + ], + "spans": [ + { + "bbox": [ + 105, + 328, + 306, + 341 + ], + "score": 1.0, + "content": "behind them follows in the next two sub-sections.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 12.5 + }, + { + "type": "title", + "bbox": [ + 108, + 353, + 250, + 364 + ], + "lines": [ + { + "bbox": [ + 106, + 353, + 252, + 366 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 252, + 366 + ], + "score": 1.0, + "content": "3.1 REGULARIZATION METHOD", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 106, + 373, + 505, + 419 + ], + "lines": [ + { + "bbox": [ + 106, + 374, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 106, + 374, + 505, + 386 + ], + "score": 1.0, + "content": "Behavior regularization is used to constrain the learned policy with the support set of the behavior", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 384, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 505, + 398 + ], + "score": 1.0, + "content": "policy. In other words, it ensures that the “difference” between the probability distributions of the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 395, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 165, + 410 + ], + "score": 1.0, + "content": "learned policy", + "type": "text" + }, + { + "bbox": [ + 165, + 396, + 195, + 408 + ], + "score": 0.93, + "content": "\\pi _ { \\boldsymbol { \\theta } } ( \\cdot | \\boldsymbol { s } )", + "type": "inline_equation" + }, + { + "bbox": [ + 195, + 395, + 277, + 410 + ], + "score": 1.0, + "content": "and behavior policy", + "type": "text" + }, + { + "bbox": [ + 278, + 396, + 308, + 408 + ], + "score": 0.93, + "content": "\\pi _ { \\beta } ( \\cdot | s )", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 395, + 505, + 410 + ], + "score": 1.0, + "content": "is small. The following divergence measures are", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 406, + 254, + 419 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 254, + 419 + ], + "score": 1.0, + "content": "most widely used in the community:", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 105, + 429, + 504, + 452 + ], + "lines": [ + { + "bbox": [ + 105, + 429, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 505, + 443 + ], + "score": 1.0, + "content": "Kernel MMD Kernel Maximum Mean Discrepancy (MMD) (Gretton et al., 2007) was first intro-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 440, + 479, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 479, + 454 + ], + "score": 1.0, + "content": "duced in (Kumar et al., 2019) to penalize the policy from diverging from the behavior policy:", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5 + }, + { + "type": "interline_equation", + "bbox": [ + 112, + 455, + 488, + 484 + ], + "lines": [ + { + "bbox": [ + 112, + 455, + 488, + 484 + ], + "spans": [ + { + "bbox": [ + 112, + 455, + 488, + 484 + ], + "score": 0.92, + "content": "\\mathbf { M M D } _ { k } ^ { 2 } ( \\pi ( \\cdot | s ) , \\pi _ { b } ( \\cdot | s ) ) = \\underset { x , x ^ { \\prime } \\sim \\pi ( \\cdot | s ) } { \\mathbb { E } } [ K ( x , x ^ { \\prime } ) ] - 2 \\underset { y \\sim \\pi ( \\cdot | s ) } { \\mathbb { E } } [ K ( x , y ) ] + \\underset { y , y ^ { \\prime } \\sim \\pi _ { b } ( \\cdot | s ) } { \\mathbb { E } } [ K ( y , y ^ { \\prime } ) ]", + "type": "interline_equation", + "image_path": "cd2d80cd63dbf86e9cdd81fce18de0b47d986b79c671d0e0add7933df2fe16ae.jpg" + } + ] + } + ], + "index": 26, + "virtual_lines": [ + { + "bbox": [ + 112, + 455, + 488, + 464.6666666666667 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 112, + 464.6666666666667, + 488, + 474.33333333333337 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 112, + 474.33333333333337, + 488, + 484.00000000000006 + ], + "spans": [], + "index": 27 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 487, + 505, + 510 + ], + "lines": [ + { + "bbox": [ + 106, + 487, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 133, + 500 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 488, + 144, + 497 + ], + "score": 0.84, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 487, + 505, + 500 + ], + "score": 1.0, + "content": "is a kernel function. Symmetric kernel functions such as Laplacian and Gaussian kernels", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 498, + 268, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 268, + 510 + ], + "score": 1.0, + "content": "are typically used (Gretton et al., 2007).", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 106, + 520, + 503, + 544 + ], + "lines": [ + { + "bbox": [ + 105, + 520, + 504, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 520, + 312, + 535 + ], + "score": 1.0, + "content": "KL divergence For two probability distributions", + "type": "text" + }, + { + "bbox": [ + 313, + 522, + 322, + 531 + ], + "score": 0.85, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 520, + 340, + 535 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 340, + 522, + 350, + 533 + ], + "score": 0.86, + "content": "Q", + "type": "inline_equation" + }, + { + "bbox": [ + 350, + 520, + 459, + 535 + ], + "score": 1.0, + "content": "on some probability space", + "type": "text" + }, + { + "bbox": [ + 459, + 523, + 467, + 533 + ], + "score": 0.8, + "content": "\\chi", + "type": "inline_equation" + }, + { + "bbox": [ + 467, + 520, + 504, + 535 + ], + "score": 1.0, + "content": ", the KL-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 532, + 252, + 546 + ], + "spans": [ + { + "bbox": [ + 106, + 532, + 176, + 546 + ], + "score": 1.0, + "content": "Divergence from", + "type": "text" + }, + { + "bbox": [ + 176, + 533, + 185, + 544 + ], + "score": 0.86, + "content": "Q", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 532, + 196, + 546 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 197, + 533, + 206, + 542 + ], + "score": 0.84, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 206, + 532, + 252, + 546 + ], + "score": 1.0, + "content": "is given as", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5 + }, + { + "type": "interline_equation", + "bbox": [ + 227, + 547, + 384, + 576 + ], + "lines": [ + { + "bbox": [ + 227, + 547, + 384, + 576 + ], + "spans": [ + { + "bbox": [ + 227, + 547, + 384, + 576 + ], + "score": 0.95, + "content": "\\mathcal { D } _ { \\mathrm { K L } } ( P , Q ) = \\int _ { x \\sim \\chi } P ( x ) \\log \\frac { P ( x ) } { Q ( x ) } d x", + "type": "interline_equation", + "image_path": "6cd685fc5bdcbbde04fa80ea98162a97577c28bd5453c4d15bf3be1b06b32315.jpg" + } + ] + } + ], + "index": 32.5, + "virtual_lines": [ + { + "bbox": [ + 227, + 547, + 384, + 561.5 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 227, + 561.5, + 384, + 576.0 + ], + "spans": [], + "index": 33 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 583, + 505, + 630 + ], + "lines": [ + { + "bbox": [ + 105, + 583, + 505, + 597 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 267, + 597 + ], + "score": 1.0, + "content": "KL divergence is assymetric and both", + "type": "text" + }, + { + "bbox": [ + 268, + 584, + 354, + 596 + ], + "score": 0.93, + "content": "\\mathcal { D } _ { \\mathrm { K L } } \\big ( \\pi _ { \\theta } \\big ( \\cdot | s \\big ) , \\pi _ { b } \\big ( \\cdot | s \\big ) \\big )", + "type": "inline_equation" + }, + { + "bbox": [ + 354, + 583, + 375, + 597 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 375, + 584, + 462, + 596 + ], + "score": 0.91, + "content": "\\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { b } ( \\cdot | s ) , \\pi _ { \\theta } ( \\cdot | s ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 583, + 505, + 597 + ], + "score": 1.0, + "content": "are valid.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 595, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 147, + 608 + ], + "score": 1.0, + "content": "However,", + "type": "text" + }, + { + "bbox": [ + 148, + 595, + 234, + 608 + ], + "score": 0.92, + "content": "\\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { b } ( \\cdot | s ) , \\pi _ { \\theta } ( \\cdot | s ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 595, + 372, + 608 + ], + "score": 1.0, + "content": "is not suitable because it requires", + "type": "text" + }, + { + "bbox": [ + 373, + 596, + 424, + 608 + ], + "score": 0.91, + "content": "\\pi _ { \\boldsymbol { \\theta } } ( a \\vert s ) \\neq 0", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 595, + 450, + 608 + ], + "score": 1.0, + "content": "when", + "type": "text" + }, + { + "bbox": [ + 451, + 595, + 501, + 608 + ], + "score": 0.91, + "content": "\\dot { \\pi _ { b } } ( a | s ) \\neq 0", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 595, + 506, + 608 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 606, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 143, + 618 + ], + "score": 1.0, + "content": "for each", + "type": "text" + }, + { + "bbox": [ + 143, + 609, + 149, + 616 + ], + "score": 0.73, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 150, + 606, + 214, + 618 + ], + "score": 1.0, + "content": ". It may assign", + "type": "text" + }, + { + "bbox": [ + 214, + 606, + 267, + 618 + ], + "score": 0.92, + "content": "\\pi _ { \\theta } ( a | s ) > 0", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 606, + 294, + 618 + ], + "score": 1.0, + "content": "when", + "type": "text" + }, + { + "bbox": [ + 294, + 606, + 347, + 618 + ], + "score": 0.95, + "content": "\\pi _ { b } ( a | s ) = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 606, + 505, + 618 + ], + "score": 1.0, + "content": ", producing out of distribution actions.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 616, + 343, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 151, + 630 + ], + "score": 1.0, + "content": "Therefore,", + "type": "text" + }, + { + "bbox": [ + 151, + 617, + 237, + 630 + ], + "score": 0.93, + "content": "\\mathcal { D } _ { \\mathrm { K L } } \\big ( \\pi _ { \\theta } \\big ( \\cdot | s \\big ) , \\pi _ { b } \\big ( \\cdot | s \\big ) \\big )", + "type": "inline_equation" + }, + { + "bbox": [ + 237, + 616, + 343, + 630 + ], + "score": 1.0, + "content": "is used for regularization.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5 + }, + { + "type": "title", + "bbox": [ + 107, + 640, + 335, + 652 + ], + "lines": [ + { + "bbox": [ + 106, + 640, + 336, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 640, + 336, + 653 + ], + "score": 1.0, + "content": "3.1.1 ANALYTICAL KL DIVERGENCE UPPER BOUND", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 107, + 659, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "All the existing behavior regularized methods estimate the divergence via samples (Kumar et al.,", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 670, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 505, + 683 + ], + "score": 1.0, + "content": "2019; Wu et al., 2019). While in theory it produces an unbiased estimator, it requires a large number", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 681, + 244, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 244, + 694 + ], + "score": 1.0, + "content": "of samples to reduce the variance.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 107, + 698, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "To stabilize the performance, the key idea is to have a low variance estimator for KL divergence. We", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 460, + 722 + ], + "score": 1.0, + "content": "obtain this by deriving an upper bound on the KL divergence between the learned policy", + "type": "text" + }, + { + "bbox": [ + 461, + 711, + 472, + 721 + ], + "score": 0.85, + "content": "\\pi _ { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "and the", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 720, + 322, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 171, + 733 + ], + "score": 1.0, + "content": "behavior policy", + "type": "text" + }, + { + "bbox": [ + 171, + 722, + 183, + 733 + ], + "score": 0.87, + "content": "\\pi _ { \\beta }", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 720, + 322, + 733 + ], + "score": 1.0, + "content": "that can be computed analytically.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 26, + 307, + 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 2021", + "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": [ + 106, + 82, + 505, + 117 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "augments either the policy improvement or the policy evaluation step with a penalty term to constrain", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 92, + 505, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 92, + 505, + 108 + ], + "score": 1.0, + "content": "the policy within the support set of the behavior policy. For simplicity of illustration, we only", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 105, + 330, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 330, + 117 + ], + "score": 1.0, + "content": "consider the policy improvement step (Wu et al., 2019):", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 105, + 82, + 505, + 117 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 171, + 134, + 439, + 155 + ], + "lines": [ + { + "bbox": [ + 171, + 134, + 439, + 155 + ], + "spans": [ + { + "bbox": [ + 171, + 134, + 439, + 155 + ], + "score": 0.89, + "content": "\\operatorname* { m a x } _ { \\pi _ { \\theta } } \\mathbb { E } _ { ( s , a , r , s ^ { \\prime } ) \\sim \\mathcal { D } } [ \\mathbb { E } _ { a ^ { \\prime \\prime } \\sim \\pi _ { \\theta } ( \\cdot \\vert s ) } [ Q _ { \\psi } ( s , a ^ { \\prime \\prime } ) ] - \\alpha \\hat { D } ( \\pi _ { \\theta } ( \\cdot \\vert s ) , \\pi _ { \\beta } ( \\cdot \\vert s ) ) ]", + "type": "interline_equation", + "image_path": "4b9148b79c78a204a759e2b24f047ee67bef674059b7d9c6ece703b049614d5a.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 171, + 134, + 439, + 155 + ], + "spans": [], + "index": 3 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 166, + 504, + 189 + ], + "lines": [ + { + "bbox": [ + 105, + 164, + 504, + 180 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 130, + 180 + ], + "score": 1.0, + "content": "Here,", + "type": "text" + }, + { + "bbox": [ + 131, + 165, + 140, + 177 + ], + "score": 0.86, + "content": "\\hat { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 164, + 191, + 180 + ], + "score": 1.0, + "content": "is a selected", + "type": "text" + }, + { + "bbox": [ + 191, + 167, + 198, + 178 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 199, + 164, + 504, + 180 + ], + "score": 1.0, + "content": "-divergence (Csiszar, 1972) measure used for behavior regularization. Zoom-´", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 177, + 267, + 191 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 267, + 191 + ], + "score": 1.0, + "content": "ing into the regularization term, we get:", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5, + "bbox_fs": [ + 105, + 164, + 504, + 191 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 244, + 192, + 366, + 219 + ], + "lines": [ + { + "bbox": [ + 244, + 192, + 366, + 219 + ], + "spans": [ + { + "bbox": [ + 244, + 192, + 366, + 219 + ], + "score": 0.94, + "content": "\\sum _ { s \\in S } ( P _ { s } \\alpha ) \\hat { D } ( \\pi _ { \\theta } ( \\cdot | s ) , \\pi _ { \\beta } ( \\cdot | s ) )", + "type": "interline_equation", + "image_path": "7a84cd86b7d50b3721174e1289d32cd24fa78f7aa8b5863bc3d92cb09c530362.jpg" + } + ] + } + ], + "index": 6.5, + "virtual_lines": [ + { + "bbox": [ + 244, + 192, + 366, + 205.5 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 244, + 205.5, + 366, + 219.0 + ], + "spans": [], + "index": 7 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 227, + 505, + 340 + ], + "lines": [ + { + "bbox": [ + 105, + 227, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 105, + 227, + 203, + 241 + ], + "score": 1.0, + "content": "In the equation above,", + "type": "text" + }, + { + "bbox": [ + 203, + 228, + 212, + 238 + ], + "score": 0.79, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 227, + 465, + 241 + ], + "score": 1.0, + "content": "denotes the states that occur in a single sampled batch and", + "type": "text" + }, + { + "bbox": [ + 465, + 228, + 477, + 239 + ], + "score": 0.89, + "content": "P _ { s }", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 227, + 505, + 241 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 239, + 506, + 253 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 184, + 253 + ], + "score": 1.0, + "content": "probability of state", + "type": "text" + }, + { + "bbox": [ + 184, + 241, + 190, + 249 + ], + "score": 0.74, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 239, + 506, + 253 + ], + "score": 1.0, + "content": "in the sampled batch. The first two improvements that we propose are targeted", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 104, + 249, + 504, + 266 + ], + "spans": [ + { + "bbox": [ + 104, + 249, + 397, + 266 + ], + "score": 1.0, + "content": "towards the following two terms in Equation 4: (1) The divergence term", + "type": "text" + }, + { + "bbox": [ + 397, + 250, + 407, + 262 + ], + "score": 0.86, + "content": "\\hat { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 249, + 492, + 266 + ], + "score": 1.0, + "content": "which for each fixed", + "type": "text" + }, + { + "bbox": [ + 492, + 253, + 504, + 263 + ], + "score": 0.82, + "content": "\\pi _ { \\theta }", + "type": "inline_equation" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 263, + 505, + 275 + ], + "spans": [ + { + "bbox": [ + 106, + 263, + 505, + 275 + ], + "score": 1.0, + "content": "determines the impact actions have on the overall objective conditional on the state, and (2) the term", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 107, + 273, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 107, + 273, + 132, + 286 + ], + "score": 0.91, + "content": "( P _ { s } \\alpha )", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 273, + 505, + 286 + ], + "score": 1.0, + "content": "which determines the impact the “divergence penalty” of each state will have on the overall", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 284, + 505, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 505, + 297 + ], + "score": 1.0, + "content": "objective function. Note that this term is dependent upon the probability of the occurrence of state in", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 294, + 505, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 505, + 309 + ], + "score": 1.0, + "content": "the sampled batch. For (1), we propose to use an analytical upper bound of KL divergence to reduce", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 307, + 505, + 320 + ], + "spans": [ + { + "bbox": [ + 106, + 307, + 505, + 320 + ], + "score": 1.0, + "content": "variance. For (2), we propose to decouple the impact of “divergence penalty” of each state from", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 318, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 318, + 505, + 331 + ], + "score": 1.0, + "content": "the probability of its occurrence. Detailed explanation of the two improvements and the rationale", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 328, + 306, + 341 + ], + "spans": [ + { + "bbox": [ + 105, + 328, + 306, + 341 + ], + "score": 1.0, + "content": "behind them follows in the next two sub-sections.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 12.5, + "bbox_fs": [ + 104, + 227, + 506, + 341 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 353, + 250, + 364 + ], + "lines": [ + { + "bbox": [ + 106, + 353, + 252, + 366 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 252, + 366 + ], + "score": 1.0, + "content": "3.1 REGULARIZATION METHOD", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 106, + 373, + 505, + 419 + ], + "lines": [ + { + "bbox": [ + 106, + 374, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 106, + 374, + 505, + 386 + ], + "score": 1.0, + "content": "Behavior regularization is used to constrain the learned policy with the support set of the behavior", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 384, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 505, + 398 + ], + "score": 1.0, + "content": "policy. In other words, it ensures that the “difference” between the probability distributions of the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 395, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 165, + 410 + ], + "score": 1.0, + "content": "learned policy", + "type": "text" + }, + { + "bbox": [ + 165, + 396, + 195, + 408 + ], + "score": 0.93, + "content": "\\pi _ { \\boldsymbol { \\theta } } ( \\cdot | \\boldsymbol { s } )", + "type": "inline_equation" + }, + { + "bbox": [ + 195, + 395, + 277, + 410 + ], + "score": 1.0, + "content": "and behavior policy", + "type": "text" + }, + { + "bbox": [ + 278, + 396, + 308, + 408 + ], + "score": 0.93, + "content": "\\pi _ { \\beta } ( \\cdot | s )", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 395, + 505, + 410 + ], + "score": 1.0, + "content": "is small. The following divergence measures are", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 406, + 254, + 419 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 254, + 419 + ], + "score": 1.0, + "content": "most widely used in the community:", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5, + "bbox_fs": [ + 105, + 374, + 505, + 419 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 429, + 504, + 452 + ], + "lines": [ + { + "bbox": [ + 105, + 429, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 505, + 443 + ], + "score": 1.0, + "content": "Kernel MMD Kernel Maximum Mean Discrepancy (MMD) (Gretton et al., 2007) was first intro-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 440, + 479, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 479, + 454 + ], + "score": 1.0, + "content": "duced in (Kumar et al., 2019) to penalize the policy from diverging from the behavior policy:", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 429, + 505, + 454 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 112, + 455, + 488, + 484 + ], + "lines": [ + { + "bbox": [ + 112, + 455, + 488, + 484 + ], + "spans": [ + { + "bbox": [ + 112, + 455, + 488, + 484 + ], + "score": 0.92, + "content": "\\mathbf { M M D } _ { k } ^ { 2 } ( \\pi ( \\cdot | s ) , \\pi _ { b } ( \\cdot | s ) ) = \\underset { x , x ^ { \\prime } \\sim \\pi ( \\cdot | s ) } { \\mathbb { E } } [ K ( x , x ^ { \\prime } ) ] - 2 \\underset { y \\sim \\pi ( \\cdot | s ) } { \\mathbb { E } } [ K ( x , y ) ] + \\underset { y , y ^ { \\prime } \\sim \\pi _ { b } ( \\cdot | s ) } { \\mathbb { E } } [ K ( y , y ^ { \\prime } ) ]", + "type": "interline_equation", + "image_path": "cd2d80cd63dbf86e9cdd81fce18de0b47d986b79c671d0e0add7933df2fe16ae.jpg" + } + ] + } + ], + "index": 26, + "virtual_lines": [ + { + "bbox": [ + 112, + 455, + 488, + 464.6666666666667 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 112, + 464.6666666666667, + 488, + 474.33333333333337 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 112, + 474.33333333333337, + 488, + 484.00000000000006 + ], + "spans": [], + "index": 27 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 487, + 505, + 510 + ], + "lines": [ + { + "bbox": [ + 106, + 487, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 133, + 500 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 488, + 144, + 497 + ], + "score": 0.84, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 487, + 505, + 500 + ], + "score": 1.0, + "content": "is a kernel function. Symmetric kernel functions such as Laplacian and Gaussian kernels", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 498, + 268, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 268, + 510 + ], + "score": 1.0, + "content": "are typically used (Gretton et al., 2007).", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28.5, + "bbox_fs": [ + 105, + 487, + 505, + 510 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 520, + 503, + 544 + ], + "lines": [ + { + "bbox": [ + 105, + 520, + 504, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 520, + 312, + 535 + ], + "score": 1.0, + "content": "KL divergence For two probability distributions", + "type": "text" + }, + { + "bbox": [ + 313, + 522, + 322, + 531 + ], + "score": 0.85, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 520, + 340, + 535 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 340, + 522, + 350, + 533 + ], + "score": 0.86, + "content": "Q", + "type": "inline_equation" + }, + { + "bbox": [ + 350, + 520, + 459, + 535 + ], + "score": 1.0, + "content": "on some probability space", + "type": "text" + }, + { + "bbox": [ + 459, + 523, + 467, + 533 + ], + "score": 0.8, + "content": "\\chi", + "type": "inline_equation" + }, + { + "bbox": [ + 467, + 520, + 504, + 535 + ], + "score": 1.0, + "content": ", the KL-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 532, + 252, + 546 + ], + "spans": [ + { + "bbox": [ + 106, + 532, + 176, + 546 + ], + "score": 1.0, + "content": "Divergence from", + "type": "text" + }, + { + "bbox": [ + 176, + 533, + 185, + 544 + ], + "score": 0.86, + "content": "Q", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 532, + 196, + 546 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 197, + 533, + 206, + 542 + ], + "score": 0.84, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 206, + 532, + 252, + 546 + ], + "score": 1.0, + "content": "is given as", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 520, + 504, + 546 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 227, + 547, + 384, + 576 + ], + "lines": [ + { + "bbox": [ + 227, + 547, + 384, + 576 + ], + "spans": [ + { + "bbox": [ + 227, + 547, + 384, + 576 + ], + "score": 0.95, + "content": "\\mathcal { D } _ { \\mathrm { K L } } ( P , Q ) = \\int _ { x \\sim \\chi } P ( x ) \\log \\frac { P ( x ) } { Q ( x ) } d x", + "type": "interline_equation", + "image_path": "6cd685fc5bdcbbde04fa80ea98162a97577c28bd5453c4d15bf3be1b06b32315.jpg" + } + ] + } + ], + "index": 32.5, + "virtual_lines": [ + { + "bbox": [ + 227, + 547, + 384, + 561.5 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 227, + 561.5, + 384, + 576.0 + ], + "spans": [], + "index": 33 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 583, + 505, + 630 + ], + "lines": [ + { + "bbox": [ + 105, + 583, + 505, + 597 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 267, + 597 + ], + "score": 1.0, + "content": "KL divergence is assymetric and both", + "type": "text" + }, + { + "bbox": [ + 268, + 584, + 354, + 596 + ], + "score": 0.93, + "content": "\\mathcal { D } _ { \\mathrm { K L } } \\big ( \\pi _ { \\theta } \\big ( \\cdot | s \\big ) , \\pi _ { b } \\big ( \\cdot | s \\big ) \\big )", + "type": "inline_equation" + }, + { + "bbox": [ + 354, + 583, + 375, + 597 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 375, + 584, + 462, + 596 + ], + "score": 0.91, + "content": "\\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { b } ( \\cdot | s ) , \\pi _ { \\theta } ( \\cdot | s ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 583, + 505, + 597 + ], + "score": 1.0, + "content": "are valid.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 595, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 147, + 608 + ], + "score": 1.0, + "content": "However,", + "type": "text" + }, + { + "bbox": [ + 148, + 595, + 234, + 608 + ], + "score": 0.92, + "content": "\\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { b } ( \\cdot | s ) , \\pi _ { \\theta } ( \\cdot | s ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 595, + 372, + 608 + ], + "score": 1.0, + "content": "is not suitable because it requires", + "type": "text" + }, + { + "bbox": [ + 373, + 596, + 424, + 608 + ], + "score": 0.91, + "content": "\\pi _ { \\boldsymbol { \\theta } } ( a \\vert s ) \\neq 0", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 595, + 450, + 608 + ], + "score": 1.0, + "content": "when", + "type": "text" + }, + { + "bbox": [ + 451, + 595, + 501, + 608 + ], + "score": 0.91, + "content": "\\dot { \\pi _ { b } } ( a | s ) \\neq 0", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 595, + 506, + 608 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 606, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 143, + 618 + ], + "score": 1.0, + "content": "for each", + "type": "text" + }, + { + "bbox": [ + 143, + 609, + 149, + 616 + ], + "score": 0.73, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 150, + 606, + 214, + 618 + ], + "score": 1.0, + "content": ". It may assign", + "type": "text" + }, + { + "bbox": [ + 214, + 606, + 267, + 618 + ], + "score": 0.92, + "content": "\\pi _ { \\theta } ( a | s ) > 0", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 606, + 294, + 618 + ], + "score": 1.0, + "content": "when", + "type": "text" + }, + { + "bbox": [ + 294, + 606, + 347, + 618 + ], + "score": 0.95, + "content": "\\pi _ { b } ( a | s ) = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 606, + 505, + 618 + ], + "score": 1.0, + "content": ", producing out of distribution actions.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 616, + 343, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 151, + 630 + ], + "score": 1.0, + "content": "Therefore,", + "type": "text" + }, + { + "bbox": [ + 151, + 617, + 237, + 630 + ], + "score": 0.93, + "content": "\\mathcal { D } _ { \\mathrm { K L } } \\big ( \\pi _ { \\theta } \\big ( \\cdot | s \\big ) , \\pi _ { b } \\big ( \\cdot | s \\big ) \\big )", + "type": "inline_equation" + }, + { + "bbox": [ + 237, + 616, + 343, + 630 + ], + "score": 1.0, + "content": "is used for regularization.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 583, + 506, + 630 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 640, + 335, + 652 + ], + "lines": [ + { + "bbox": [ + 106, + 640, + 336, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 640, + 336, + 653 + ], + "score": 1.0, + "content": "3.1.1 ANALYTICAL KL DIVERGENCE UPPER BOUND", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 107, + 659, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "All the existing behavior regularized methods estimate the divergence via samples (Kumar et al.,", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 670, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 505, + 683 + ], + "score": 1.0, + "content": "2019; Wu et al., 2019). While in theory it produces an unbiased estimator, it requires a large number", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 681, + 244, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 244, + 694 + ], + "score": 1.0, + "content": "of samples to reduce the variance.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40, + "bbox_fs": [ + 105, + 660, + 505, + 694 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 698, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "To stabilize the performance, the key idea is to have a low variance estimator for KL divergence. We", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 460, + 722 + ], + "score": 1.0, + "content": "obtain this by deriving an upper bound on the KL divergence between the learned policy", + "type": "text" + }, + { + "bbox": [ + 461, + 711, + 472, + 721 + ], + "score": 0.85, + "content": "\\pi _ { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "and the", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 720, + 322, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 171, + 733 + ], + "score": 1.0, + "content": "behavior policy", + "type": "text" + }, + { + "bbox": [ + 171, + 722, + 183, + 733 + ], + "score": 0.87, + "content": "\\pi _ { \\beta }", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 720, + 322, + 733 + ], + "score": 1.0, + "content": "that can be computed analytically.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43, + "bbox_fs": [ + 105, + 699, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 128 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 181, + 95 + ], + "score": 1.0, + "content": "Assume we learn", + "type": "text" + }, + { + "bbox": [ + 181, + 85, + 193, + 95 + ], + "score": 0.84, + "content": "\\pi _ { \\beta }", + "type": "inline_equation" + }, + { + "bbox": [ + 194, + 82, + 506, + 95 + ], + "score": 1.0, + "content": "using a latent variable model (e.g. VAE (Kingma & Welling, 2014)) with", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 92, + 504, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 92, + 169, + 106 + ], + "score": 1.0, + "content": "latent variable", + "type": "text" + }, + { + "bbox": [ + 169, + 94, + 178, + 103 + ], + "score": 0.81, + "content": "Z", + "type": "inline_equation" + }, + { + "bbox": [ + 178, + 92, + 442, + 106 + ], + "score": 1.0, + "content": ". According to the evidence lower bound (ELBO), we obtain", + "type": "text" + }, + { + "bbox": [ + 443, + 93, + 504, + 106 + ], + "score": 0.88, + "content": "\\log \\pi _ { \\beta } ( a | s ) \\geq", + "type": "inline_equation" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 104, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 104, + 271, + 117 + ], + "score": 0.89, + "content": "\\mathbb { E } _ { z \\sim q ( z ) } [ \\log p ( a | s , z ) ] - \\mathcal { D } _ { \\mathrm { K L } } ( \\bar { q } ( z ) | | p ( z ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 104, + 301, + 118 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 302, + 104, + 320, + 117 + ], + "score": 0.92, + "content": "q ( z )", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 104, + 506, + 118 + ], + "score": 1.0, + "content": "is the approximated posterior distribution and", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 107, + 115, + 338, + 130 + ], + "spans": [ + { + "bbox": [ + 107, + 117, + 125, + 128 + ], + "score": 0.91, + "content": "p ( z )", + "type": "inline_equation" + }, + { + "bbox": [ + 126, + 115, + 338, + 130 + ], + "score": 1.0, + "content": "is the prior. Then, the KL divergence is bounded by:", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "interline_equation", + "bbox": [ + 110, + 133, + 499, + 181 + ], + "lines": [ + { + "bbox": [ + 110, + 133, + 499, + 181 + ], + "spans": [ + { + "bbox": [ + 110, + 133, + 499, + 181 + ], + "score": 0.93, + "content": "\\begin{array} { r l } & { \\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { \\theta } ( \\cdot | s ) | | \\pi _ { \\beta } ( \\cdot | s ) ) = \\mathbb { E } _ { a \\sim \\pi _ { \\theta } } [ \\log \\pi _ { \\theta } ( a | s ) ] - \\mathbb { E } _ { a \\sim \\pi _ { \\theta } } [ \\log \\pi _ { \\beta } ( a | s ) ] } \\\\ & { \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\mathbb { E } _ { a \\sim \\pi _ { \\theta } } [ \\log \\pi _ { \\beta } ( a | s ) ] - \\mathbb { E } _ { \\kappa \\mathrm { L } } ( q ( z ) | | p ( z ) ) ] } \\\\ & { \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad ( \\mathcal { T } _ { a \\sim \\pi _ { \\theta } } [ \\log ( a | s ) ] + \\mathcal { D } _ { \\mathrm { K L } } ( q ( z ) | | p ( z ) ) ] } \\\\ & { \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad ( \\mathcal { T } _ { a \\sim \\pi _ { \\theta } , z \\sim q ( z ) } [ \\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { \\theta } ( \\cdot | s ) | | p ( \\cdot | s , z ) ) + \\mathcal { D } _ { \\mathrm { K L } } ( q ( z ) | | p ( z ) ) ] } \\\\ & { \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad ( \\mathcal { T } _ { a \\sim \\pi _ { \\theta } , z \\sim q ( z ) } [ \\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { \\theta } ( \\cdot | s ) | | p ( \\cdot | s , z ) ) + \\mathcal { D } _ { \\mathrm { K L } } ( q ( z ) | | p ( z ) ) ] } \\end{array}", + "type": "interline_equation", + "image_path": "9c311e6daa1f995fa43e12a5c05e932603e3c7d11f6647e99b24366338eaf3e0.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 110, + 133, + 499, + 149.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 110, + 149.0, + 499, + 165.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 110, + 165.0, + 499, + 181.0 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 185, + 504, + 230 + ], + "lines": [ + { + "bbox": [ + 105, + 185, + 505, + 198 + ], + "spans": [ + { + "bbox": [ + 105, + 185, + 185, + 198 + ], + "score": 1.0, + "content": "Thus, if we choose", + "type": "text" + }, + { + "bbox": [ + 185, + 187, + 218, + 198 + ], + "score": 0.9, + "content": "p ( \\cdot | s , z )", + "type": "inline_equation" + }, + { + "bbox": [ + 218, + 185, + 505, + 198 + ], + "score": 1.0, + "content": "to be a tractable distribution, Equation 7 can be computed analytically.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 195, + 506, + 209 + ], + "spans": [ + { + "bbox": [ + 105, + 195, + 187, + 209 + ], + "score": 1.0, + "content": "Note that although", + "type": "text" + }, + { + "bbox": [ + 187, + 199, + 220, + 209 + ], + "score": 0.93, + "content": "p ( \\cdot | s , z )", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 195, + 506, + 209 + ], + "score": 1.0, + "content": "has a special form (e.g. Gaussian), the latent variable model can in", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 207, + 506, + 221 + ], + "spans": [ + { + "bbox": [ + 105, + 207, + 506, + 221 + ], + "score": 1.0, + "content": "theory represent any probability distribution without sacrificing the expressiveness. In practice, we", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 218, + 291, + 231 + ], + "spans": [ + { + "bbox": [ + 106, + 218, + 137, + 230 + ], + "score": 1.0, + "content": "choose", + "type": "text" + }, + { + "bbox": [ + 137, + 220, + 170, + 231 + ], + "score": 0.92, + "content": "p ( \\cdot | s , z )", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 218, + 291, + 230 + ], + "score": 1.0, + "content": "to be a Gaussian distribution.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8.5 + }, + { + "type": "title", + "bbox": [ + 107, + 245, + 321, + 257 + ], + "lines": [ + { + "bbox": [ + 105, + 244, + 322, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 322, + 257 + ], + "score": 1.0, + "content": "3.2 STATE DEPENDENT LAGRANGE MULTIPLIER", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 265, + 505, + 355 + ], + "lines": [ + { + "bbox": [ + 105, + 265, + 505, + 280 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 169, + 280 + ], + "score": 1.0, + "content": "From the term", + "type": "text" + }, + { + "bbox": [ + 170, + 267, + 195, + 279 + ], + "score": 0.9, + "content": "( P _ { s } \\alpha )", + "type": "inline_equation" + }, + { + "bbox": [ + 195, + 265, + 505, + 280 + ], + "score": 1.0, + "content": "in Equation 4, one can infer that the “penalty budget” of divergence mea-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 278, + 505, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 278, + 505, + 290 + ], + "score": 1.0, + "content": "sure gets distributed among the states in amounts inversely proportional to the probability of the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 289, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 105, + 289, + 505, + 301 + ], + "score": 1.0, + "content": "occurrence of the states in the sampled batch. If we assume the batches are sampled uniformly, this", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 300, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 300, + 395, + 312 + ], + "score": 1.0, + "content": "implies that the states which are more numerous in the offline dataset", + "type": "text" + }, + { + "bbox": [ + 395, + 300, + 405, + 309 + ], + "score": 0.79, + "content": "\\mathcal { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 300, + 505, + 312 + ], + "score": 1.0, + "content": "i.e. the states that have", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 311, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 105, + 311, + 505, + 323 + ], + "score": 1.0, + "content": "been explored more thoroughly are restricted from deviating from the behavior policy. Whereas the", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 322, + 506, + 334 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 506, + 334 + ], + "score": 1.0, + "content": "less numerous state that have had limited exploration enjoy more freedom for deviation. This is", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 332, + 506, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 506, + 345 + ], + "score": 1.0, + "content": "undesirable as restricting highly explored states is overly conservative while allowing less explored", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 343, + 276, + 356 + ], + "spans": [ + { + "bbox": [ + 105, + 343, + 276, + 356 + ], + "score": 1.0, + "content": "states to deviate can lead to OOD actions.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 108, + 360, + 411, + 372 + ], + "lines": [ + { + "bbox": [ + 106, + 358, + 411, + 374 + ], + "spans": [ + { + "bbox": [ + 106, + 358, + 411, + 374 + ], + "score": 1.0, + "content": "To address this we add a state wise constraint for KL divergence as follows:", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "interline_equation", + "bbox": [ + 108, + 378, + 434, + 393 + ], + "lines": [ + { + "bbox": [ + 108, + 378, + 434, + 393 + ], + "spans": [ + { + "bbox": [ + 108, + 378, + 434, + 393 + ], + "score": 0.42, + "content": "\\operatorname* { m a x } _ { \\pi _ { \\alpha } \\Lambda } \\mathbb { E } _ { s \\sim \\mathcal { D } } [ \\mathbb { E } _ { a ^ { \\prime } \\sim \\pi _ { \\theta } ( \\cdot | s ) } [ Q _ { \\psi } ( s , a ^ { \\prime } ) ] ] \\mathrm { ~ s . t . ~ } \\mathcal { D } _ { K L } ( \\pi _ { \\theta } ( \\cdot | s ) , \\pi _ { \\beta } ( \\cdot | s ) ) \\leq \\epsilon _ { \\mathrm { K L } } , \\forall s \\quad \\mathrm { ( p o l i c ) } .", + "type": "interline_equation", + "image_path": "67a260b9cd216ce101dc88c6442e968b7cc7cc01bab77b358d67684205133b4c.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 108, + 378, + 434, + 393 + ], + "spans": [], + "index": 21 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 410, + 504, + 433 + ], + "lines": [ + { + "bbox": [ + 105, + 408, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 505, + 424 + ], + "score": 1.0, + "content": "This translates to assignment of state dependent Lagrange multipliers when solved using dual gra-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 420, + 164, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 164, + 434 + ], + "score": 1.0, + "content": "dient descent:", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "interline_equation", + "bbox": [ + 175, + 438, + 435, + 458 + ], + "lines": [ + { + "bbox": [ + 175, + 438, + 435, + 458 + ], + "spans": [ + { + "bbox": [ + 175, + 438, + 435, + 458 + ], + "score": 0.88, + "content": "\\operatorname* { m a x } _ { \\pi _ { \\theta } } \\mathbb { E } _ { s \\sim \\mathcal { D } } \\big [ \\mathbb { E } _ { a ^ { \\prime } \\sim \\pi _ { \\theta } ( \\cdot \\vert s ) } [ Q _ { \\psi } ( s , a ^ { \\prime } ) - \\alpha ( s ) \\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { \\theta } ( \\cdot \\vert s ) , \\pi _ { \\beta } ( \\cdot \\vert s ) ) ] \\big ]", + "type": "interline_equation", + "image_path": "b7de9ef8e56f4ef39fbd7836ff7e55dad91bae5a307f059e7e381da859601c1c.jpg" + } + ] + } + ], + "index": 24, + "virtual_lines": [ + { + "bbox": [ + 175, + 438, + 435, + 458 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 465, + 505, + 487 + ], + "lines": [ + { + "bbox": [ + 105, + 464, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 505, + 478 + ], + "score": 1.0, + "content": "Maintaining a Lagrange multiplier for each state is impractical for large datasets. In practice, we", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 476, + 274, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 476, + 160, + 488 + ], + "score": 1.0, + "content": "parameterize", + "type": "text" + }, + { + "bbox": [ + 160, + 476, + 180, + 488 + ], + "score": 0.91, + "content": "\\alpha ( s )", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 476, + 274, + 488 + ], + "score": 1.0, + "content": "with a neural network.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + }, + { + "type": "title", + "bbox": [ + 107, + 503, + 320, + 514 + ], + "lines": [ + { + "bbox": [ + 105, + 502, + 321, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 321, + 514 + ], + "score": 1.0, + "content": "3.3 GRADIENT PENALIZED POLICY EVALUATION", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 106, + 523, + 505, + 624 + ], + "lines": [ + { + "bbox": [ + 106, + 523, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 505, + 536 + ], + "score": 1.0, + "content": "The fundamental challenge in offline reinforcement learning is to mitigate the impact of erroneous", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 535, + 505, + 547 + ], + "spans": [ + { + "bbox": [ + 106, + 535, + 505, + 547 + ], + "score": 1.0, + "content": "Q values that are evaluated at out-of-distribution actions and used in policy evaluation. Due to the", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 545, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 105, + 545, + 505, + 559 + ], + "score": 1.0, + "content": "limited representation capacity of neural networks, such actions are unavoidable for large datasets,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 557, + 504, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 557, + 504, + 569 + ], + "score": 1.0, + "content": "even with state-dependent behavior regularization. CQL (Kumar et al., 2020) resolves this problem", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 568, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 505, + 579 + ], + "score": 1.0, + "content": "by optimizing a conservative lower bound of the Q value. The key idea in this paper is to bound", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 578, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 505, + 591 + ], + "score": 1.0, + "content": "the Q value at the out-of-distribution actions such that their values are not greater than the Q", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 589, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 106, + 589, + 506, + 601 + ], + "score": 1.0, + "content": "value of in-distribution actions. We achieve this by augmenting the policy evaluation step with a", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 600, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 506, + 614 + ], + "score": 1.0, + "content": "gradient penalty regularization term. To elaborate our approach, we first analyze the gradient of the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 611, + 210, + 625 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 210, + 625 + ], + "score": 1.0, + "content": "policy improvement step:", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 32 + }, + { + "type": "interline_equation", + "bbox": [ + 112, + 631, + 487, + 664 + ], + "lines": [ + { + "bbox": [ + 112, + 631, + 487, + 664 + ], + "spans": [ + { + "bbox": [ + 112, + 631, + 487, + 664 + ], + "score": 0.93, + "content": "\\nabla _ { \\theta } J \\approx \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\nabla _ { a _ { i } } Q _ { \\phi } ( s , a ) | _ { s = s _ { i } , a = a _ { i } } \\nabla _ { \\theta } \\pi _ { \\theta } ( a | s ) | _ { s = s _ { i } , a = a _ { i } } - \\alpha ( s _ { i } ) \\nabla _ { \\theta } \\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { \\theta } ( \\cdot | s ) , \\pi _ { \\beta } ( \\cdot | s ) )", + "type": "interline_equation", + "image_path": "5492de82632953466d1e3fc4b0134796049a2c861891e41483934ab895bcd76b.jpg" + } + ] + } + ], + "index": 38, + "virtual_lines": [ + { + "bbox": [ + 112, + 631, + 487, + 642.0 + ], + "spans": [], + "index": 37 + }, + { + "bbox": [ + 112, + 642.0, + 487, + 653.0 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 112, + 653.0, + 487, + 664.0 + ], + "spans": [], + "index": 39 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 676, + 505, + 689 + ], + "score": 1.0, + "content": "If the current policy produces out-of-distribution actions and the Q network erroneously generalizes", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "score": 1.0, + "content": "in such a way that the gradient of Q network is monotonically increasing, this leads to the unbounded", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "value of the Q network and the failure of the behavior regularization. We created a toy example to", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "score": 1.0, + "content": "illustrate this phenomenon in Appendix A. The analysis suggests that if we penalize the gradient", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 718, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 718, + 505, + 734 + ], + "score": 1.0, + "content": "of the Q network with respect to the out-of-distribution actions such that they are close to zero,", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 42 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 12, + "width": 8 + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 106, + 26, + 307, + 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 2021", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 128 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 181, + 95 + ], + "score": 1.0, + "content": "Assume we learn", + "type": "text" + }, + { + "bbox": [ + 181, + 85, + 193, + 95 + ], + "score": 0.84, + "content": "\\pi _ { \\beta }", + "type": "inline_equation" + }, + { + "bbox": [ + 194, + 82, + 506, + 95 + ], + "score": 1.0, + "content": "using a latent variable model (e.g. VAE (Kingma & Welling, 2014)) with", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 92, + 504, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 92, + 169, + 106 + ], + "score": 1.0, + "content": "latent variable", + "type": "text" + }, + { + "bbox": [ + 169, + 94, + 178, + 103 + ], + "score": 0.81, + "content": "Z", + "type": "inline_equation" + }, + { + "bbox": [ + 178, + 92, + 442, + 106 + ], + "score": 1.0, + "content": ". According to the evidence lower bound (ELBO), we obtain", + "type": "text" + }, + { + "bbox": [ + 443, + 93, + 504, + 106 + ], + "score": 0.88, + "content": "\\log \\pi _ { \\beta } ( a | s ) \\geq", + "type": "inline_equation" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 104, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 104, + 271, + 117 + ], + "score": 0.89, + "content": "\\mathbb { E } _ { z \\sim q ( z ) } [ \\log p ( a | s , z ) ] - \\mathcal { D } _ { \\mathrm { K L } } ( \\bar { q } ( z ) | | p ( z ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 104, + 301, + 118 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 302, + 104, + 320, + 117 + ], + "score": 0.92, + "content": "q ( z )", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 104, + 506, + 118 + ], + "score": 1.0, + "content": "is the approximated posterior distribution and", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 107, + 115, + 338, + 130 + ], + "spans": [ + { + "bbox": [ + 107, + 117, + 125, + 128 + ], + "score": 0.91, + "content": "p ( z )", + "type": "inline_equation" + }, + { + "bbox": [ + 126, + 115, + 338, + 130 + ], + "score": 1.0, + "content": "is the prior. Then, the KL divergence is bounded by:", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5, + "bbox_fs": [ + 105, + 82, + 506, + 130 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 110, + 133, + 499, + 181 + ], + "lines": [ + { + "bbox": [ + 110, + 133, + 499, + 181 + ], + "spans": [ + { + "bbox": [ + 110, + 133, + 499, + 181 + ], + "score": 0.93, + "content": "\\begin{array} { r l } & { \\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { \\theta } ( \\cdot | s ) | | \\pi _ { \\beta } ( \\cdot | s ) ) = \\mathbb { E } _ { a \\sim \\pi _ { \\theta } } [ \\log \\pi _ { \\theta } ( a | s ) ] - \\mathbb { E } _ { a \\sim \\pi _ { \\theta } } [ \\log \\pi _ { \\beta } ( a | s ) ] } \\\\ & { \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\mathbb { E } _ { a \\sim \\pi _ { \\theta } } [ \\log \\pi _ { \\beta } ( a | s ) ] - \\mathbb { E } _ { \\kappa \\mathrm { L } } ( q ( z ) | | p ( z ) ) ] } \\\\ & { \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad ( \\mathcal { T } _ { a \\sim \\pi _ { \\theta } } [ \\log ( a | s ) ] + \\mathcal { D } _ { \\mathrm { K L } } ( q ( z ) | | p ( z ) ) ] } \\\\ & { \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad ( \\mathcal { T } _ { a \\sim \\pi _ { \\theta } , z \\sim q ( z ) } [ \\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { \\theta } ( \\cdot | s ) | | p ( \\cdot | s , z ) ) + \\mathcal { D } _ { \\mathrm { K L } } ( q ( z ) | | p ( z ) ) ] } \\\\ & { \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad ( \\mathcal { T } _ { a \\sim \\pi _ { \\theta } , z \\sim q ( z ) } [ \\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { \\theta } ( \\cdot | s ) | | p ( \\cdot | s , z ) ) + \\mathcal { D } _ { \\mathrm { K L } } ( q ( z ) | | p ( z ) ) ] } \\end{array}", + "type": "interline_equation", + "image_path": "9c311e6daa1f995fa43e12a5c05e932603e3c7d11f6647e99b24366338eaf3e0.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 110, + 133, + 499, + 149.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 110, + 149.0, + 499, + 165.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 110, + 165.0, + 499, + 181.0 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 185, + 504, + 230 + ], + "lines": [ + { + "bbox": [ + 105, + 185, + 505, + 198 + ], + "spans": [ + { + "bbox": [ + 105, + 185, + 185, + 198 + ], + "score": 1.0, + "content": "Thus, if we choose", + "type": "text" + }, + { + "bbox": [ + 185, + 187, + 218, + 198 + ], + "score": 0.9, + "content": "p ( \\cdot | s , z )", + "type": "inline_equation" + }, + { + "bbox": [ + 218, + 185, + 505, + 198 + ], + "score": 1.0, + "content": "to be a tractable distribution, Equation 7 can be computed analytically.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 195, + 506, + 209 + ], + "spans": [ + { + "bbox": [ + 105, + 195, + 187, + 209 + ], + "score": 1.0, + "content": "Note that although", + "type": "text" + }, + { + "bbox": [ + 187, + 199, + 220, + 209 + ], + "score": 0.93, + "content": "p ( \\cdot | s , z )", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 195, + 506, + 209 + ], + "score": 1.0, + "content": "has a special form (e.g. Gaussian), the latent variable model can in", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 207, + 506, + 221 + ], + "spans": [ + { + "bbox": [ + 105, + 207, + 506, + 221 + ], + "score": 1.0, + "content": "theory represent any probability distribution without sacrificing the expressiveness. In practice, we", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 218, + 291, + 231 + ], + "spans": [ + { + "bbox": [ + 106, + 218, + 137, + 230 + ], + "score": 1.0, + "content": "choose", + "type": "text" + }, + { + "bbox": [ + 137, + 220, + 170, + 231 + ], + "score": 0.92, + "content": "p ( \\cdot | s , z )", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 218, + 291, + 230 + ], + "score": 1.0, + "content": "to be a Gaussian distribution.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 185, + 506, + 231 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 245, + 321, + 257 + ], + "lines": [ + { + "bbox": [ + 105, + 244, + 322, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 322, + 257 + ], + "score": 1.0, + "content": "3.2 STATE DEPENDENT LAGRANGE MULTIPLIER", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 265, + 505, + 355 + ], + "lines": [ + { + "bbox": [ + 105, + 265, + 505, + 280 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 169, + 280 + ], + "score": 1.0, + "content": "From the term", + "type": "text" + }, + { + "bbox": [ + 170, + 267, + 195, + 279 + ], + "score": 0.9, + "content": "( P _ { s } \\alpha )", + "type": "inline_equation" + }, + { + "bbox": [ + 195, + 265, + 505, + 280 + ], + "score": 1.0, + "content": "in Equation 4, one can infer that the “penalty budget” of divergence mea-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 278, + 505, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 278, + 505, + 290 + ], + "score": 1.0, + "content": "sure gets distributed among the states in amounts inversely proportional to the probability of the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 289, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 105, + 289, + 505, + 301 + ], + "score": 1.0, + "content": "occurrence of the states in the sampled batch. If we assume the batches are sampled uniformly, this", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 300, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 300, + 395, + 312 + ], + "score": 1.0, + "content": "implies that the states which are more numerous in the offline dataset", + "type": "text" + }, + { + "bbox": [ + 395, + 300, + 405, + 309 + ], + "score": 0.79, + "content": "\\mathcal { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 300, + 505, + 312 + ], + "score": 1.0, + "content": "i.e. the states that have", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 311, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 105, + 311, + 505, + 323 + ], + "score": 1.0, + "content": "been explored more thoroughly are restricted from deviating from the behavior policy. Whereas the", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 322, + 506, + 334 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 506, + 334 + ], + "score": 1.0, + "content": "less numerous state that have had limited exploration enjoy more freedom for deviation. This is", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 332, + 506, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 506, + 345 + ], + "score": 1.0, + "content": "undesirable as restricting highly explored states is overly conservative while allowing less explored", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 343, + 276, + 356 + ], + "spans": [ + { + "bbox": [ + 105, + 343, + 276, + 356 + ], + "score": 1.0, + "content": "states to deviate can lead to OOD actions.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 265, + 506, + 356 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 360, + 411, + 372 + ], + "lines": [ + { + "bbox": [ + 106, + 358, + 411, + 374 + ], + "spans": [ + { + "bbox": [ + 106, + 358, + 411, + 374 + ], + "score": 1.0, + "content": "To address this we add a state wise constraint for KL divergence as follows:", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20, + "bbox_fs": [ + 106, + 358, + 411, + 374 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 108, + 378, + 434, + 393 + ], + "lines": [ + { + "bbox": [ + 108, + 378, + 434, + 393 + ], + "spans": [ + { + "bbox": [ + 108, + 378, + 434, + 393 + ], + "score": 0.42, + "content": "\\operatorname* { m a x } _ { \\pi _ { \\alpha } \\Lambda } \\mathbb { E } _ { s \\sim \\mathcal { D } } [ \\mathbb { E } _ { a ^ { \\prime } \\sim \\pi _ { \\theta } ( \\cdot | s ) } [ Q _ { \\psi } ( s , a ^ { \\prime } ) ] ] \\mathrm { ~ s . t . ~ } \\mathcal { D } _ { K L } ( \\pi _ { \\theta } ( \\cdot | s ) , \\pi _ { \\beta } ( \\cdot | s ) ) \\leq \\epsilon _ { \\mathrm { K L } } , \\forall s \\quad \\mathrm { ( p o l i c ) } .", + "type": "interline_equation", + "image_path": "67a260b9cd216ce101dc88c6442e968b7cc7cc01bab77b358d67684205133b4c.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 108, + 378, + 434, + 393 + ], + "spans": [], + "index": 21 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 410, + 504, + 433 + ], + "lines": [ + { + "bbox": [ + 105, + 408, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 505, + 424 + ], + "score": 1.0, + "content": "This translates to assignment of state dependent Lagrange multipliers when solved using dual gra-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 420, + 164, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 164, + 434 + ], + "score": 1.0, + "content": "dient descent:", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 408, + 505, + 434 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 175, + 438, + 435, + 458 + ], + "lines": [ + { + "bbox": [ + 175, + 438, + 435, + 458 + ], + "spans": [ + { + "bbox": [ + 175, + 438, + 435, + 458 + ], + "score": 0.88, + "content": "\\operatorname* { m a x } _ { \\pi _ { \\theta } } \\mathbb { E } _ { s \\sim \\mathcal { D } } \\big [ \\mathbb { E } _ { a ^ { \\prime } \\sim \\pi _ { \\theta } ( \\cdot \\vert s ) } [ Q _ { \\psi } ( s , a ^ { \\prime } ) - \\alpha ( s ) \\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { \\theta } ( \\cdot \\vert s ) , \\pi _ { \\beta } ( \\cdot \\vert s ) ) ] \\big ]", + "type": "interline_equation", + "image_path": "b7de9ef8e56f4ef39fbd7836ff7e55dad91bae5a307f059e7e381da859601c1c.jpg" + } + ] + } + ], + "index": 24, + "virtual_lines": [ + { + "bbox": [ + 175, + 438, + 435, + 458 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 465, + 505, + 487 + ], + "lines": [ + { + "bbox": [ + 105, + 464, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 505, + 478 + ], + "score": 1.0, + "content": "Maintaining a Lagrange multiplier for each state is impractical for large datasets. In practice, we", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 476, + 274, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 476, + 160, + 488 + ], + "score": 1.0, + "content": "parameterize", + "type": "text" + }, + { + "bbox": [ + 160, + 476, + 180, + 488 + ], + "score": 0.91, + "content": "\\alpha ( s )", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 476, + 274, + 488 + ], + "score": 1.0, + "content": "with a neural network.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5, + "bbox_fs": [ + 105, + 464, + 505, + 488 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 503, + 320, + 514 + ], + "lines": [ + { + "bbox": [ + 105, + 502, + 321, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 321, + 514 + ], + "score": 1.0, + "content": "3.3 GRADIENT PENALIZED POLICY EVALUATION", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 106, + 523, + 505, + 624 + ], + "lines": [ + { + "bbox": [ + 106, + 523, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 505, + 536 + ], + "score": 1.0, + "content": "The fundamental challenge in offline reinforcement learning is to mitigate the impact of erroneous", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 535, + 505, + 547 + ], + "spans": [ + { + "bbox": [ + 106, + 535, + 505, + 547 + ], + "score": 1.0, + "content": "Q values that are evaluated at out-of-distribution actions and used in policy evaluation. Due to the", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 545, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 105, + 545, + 505, + 559 + ], + "score": 1.0, + "content": "limited representation capacity of neural networks, such actions are unavoidable for large datasets,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 557, + 504, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 557, + 504, + 569 + ], + "score": 1.0, + "content": "even with state-dependent behavior regularization. CQL (Kumar et al., 2020) resolves this problem", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 568, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 505, + 579 + ], + "score": 1.0, + "content": "by optimizing a conservative lower bound of the Q value. The key idea in this paper is to bound", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 578, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 505, + 591 + ], + "score": 1.0, + "content": "the Q value at the out-of-distribution actions such that their values are not greater than the Q", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 589, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 106, + 589, + 506, + 601 + ], + "score": 1.0, + "content": "value of in-distribution actions. We achieve this by augmenting the policy evaluation step with a", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 600, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 506, + 614 + ], + "score": 1.0, + "content": "gradient penalty regularization term. To elaborate our approach, we first analyze the gradient of the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 611, + 210, + 625 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 210, + 625 + ], + "score": 1.0, + "content": "policy improvement step:", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 32, + "bbox_fs": [ + 105, + 523, + 506, + 625 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 112, + 631, + 487, + 664 + ], + "lines": [ + { + "bbox": [ + 112, + 631, + 487, + 664 + ], + "spans": [ + { + "bbox": [ + 112, + 631, + 487, + 664 + ], + "score": 0.93, + "content": "\\nabla _ { \\theta } J \\approx \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\nabla _ { a _ { i } } Q _ { \\phi } ( s , a ) | _ { s = s _ { i } , a = a _ { i } } \\nabla _ { \\theta } \\pi _ { \\theta } ( a | s ) | _ { s = s _ { i } , a = a _ { i } } - \\alpha ( s _ { i } ) \\nabla _ { \\theta } \\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { \\theta } ( \\cdot | s ) , \\pi _ { \\beta } ( \\cdot | s ) )", + "type": "interline_equation", + "image_path": "5492de82632953466d1e3fc4b0134796049a2c861891e41483934ab895bcd76b.jpg" + } + ] + } + ], + "index": 38, + "virtual_lines": [ + { + "bbox": [ + 112, + 631, + 487, + 642.0 + ], + "spans": [], + "index": 37 + }, + { + "bbox": [ + 112, + 642.0, + 487, + 653.0 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 112, + 653.0, + 487, + 664.0 + ], + "spans": [], + "index": 39 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 676, + 505, + 689 + ], + "score": 1.0, + "content": "If the current policy produces out-of-distribution actions and the Q network erroneously generalizes", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "score": 1.0, + "content": "in such a way that the gradient of Q network is monotonically increasing, this leads to the unbounded", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "value of the Q network and the failure of the behavior regularization. We created a toy example to", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "score": 1.0, + "content": "illustrate this phenomenon in Appendix A. The analysis suggests that if we penalize the gradient", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 718, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 718, + 505, + 734 + ], + "score": 1.0, + "content": "of the Q network with respect to the out-of-distribution actions such that they are close to zero,", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 42, + "bbox_fs": [ + 105, + 676, + 505, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 81, + 379, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 380, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 380, + 94 + ], + "score": 1.0, + "content": "Algorithm 1 BRAC+: Improved Behavior Regularized Actor Critic", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 110, + 99, + 499, + 254 + ], + "lines": [ + { + "bbox": [ + 109, + 97, + 502, + 114 + ], + "spans": [ + { + "bbox": [ + 109, + 97, + 232, + 114 + ], + "score": 1.0, + "content": "1: Train the behavior policy", + "type": "text" + }, + { + "bbox": [ + 232, + 102, + 244, + 113 + ], + "score": 0.84, + "content": "\\pi _ { \\beta }", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 97, + 338, + 114 + ], + "score": 1.0, + "content": "on the offline dataset", + "type": "text" + }, + { + "bbox": [ + 339, + 99, + 443, + 113 + ], + "score": 0.91, + "content": "\\mathcal { D } = \\{ ( s _ { i } , a _ { i } , r _ { i } , s _ { i } ^ { ' } ) \\} _ { i = 1 } ^ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 443, + 97, + 502, + 114 + ], + "score": 1.0, + "content": "via maximum", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 120, + 110, + 363, + 131 + ], + "spans": [ + { + "bbox": [ + 120, + 110, + 212, + 131 + ], + "score": 1.0, + "content": "likelihood estimation:", + "type": "text" + }, + { + "bbox": [ + 213, + 111, + 363, + 127 + ], + "score": 0.87, + "content": "\\begin{array} { r } { \\pi _ { \\beta } = \\arg \\operatorname* { m a x } _ { \\pi _ { \\beta } } \\sum _ { i = 1 } ^ { N } \\log \\pi _ { \\beta } ( a _ { i } | s _ { i } ) } \\end{array}", + "type": "inline_equation" + } + ], + "index": 2 + }, + { + "bbox": [ + 109, + 124, + 330, + 141 + ], + "spans": [ + { + "bbox": [ + 109, + 124, + 205, + 141 + ], + "score": 1.0, + "content": "2: Train initial policy:", + "type": "text" + }, + { + "bbox": [ + 205, + 128, + 330, + 139 + ], + "score": 0.86, + "content": "\\begin{array} { r } { \\pi _ { \\theta } = \\arg \\operatorname* { m i n } _ { \\pi _ { \\theta } \\in \\Pi } \\mathcal { D } _ { \\mathrm { K L } } ( \\pi , \\pi _ { \\beta } ) } \\end{array}", + "type": "inline_equation" + } + ], + "index": 3 + }, + { + "bbox": [ + 111, + 137, + 480, + 153 + ], + "spans": [ + { + "bbox": [ + 111, + 137, + 220, + 153 + ], + "score": 1.0, + "content": "3: Train initial Q network:", + "type": "text" + }, + { + "bbox": [ + 220, + 139, + 480, + 153 + ], + "score": 0.81, + "content": "\\begin{array} { r } { Q _ { \\psi } = \\arg \\operatorname* { m i n } _ { \\psi } [ ( Q _ { \\psi } ( s , a ) - ( r ( s , a ) + \\gamma \\mathbb { E } _ { a ^ { \\prime } \\sim \\pi _ { \\theta } } Q _ { \\psi ^ { \\prime } } ( s ^ { \\prime } , a ^ { \\prime } ) ) ) ] ^ { 2 } } \\end{array}", + "type": "inline_equation" + } + ], + "index": 4 + }, + { + "bbox": [ + 110, + 151, + 194, + 162 + ], + "spans": [ + { + "bbox": [ + 110, + 151, + 138, + 162 + ], + "score": 1.0, + "content": "4: for", + "type": "text" + }, + { + "bbox": [ + 138, + 151, + 179, + 162 + ], + "score": 0.87, + "content": "e = 1 : E", + "type": "inline_equation" + }, + { + "bbox": [ + 179, + 151, + 194, + 162 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 110, + 162, + 201, + 174 + ], + "spans": [ + { + "bbox": [ + 110, + 162, + 121, + 174 + ], + "score": 1.0, + "content": "5:", + "type": "text" + }, + { + "bbox": [ + 132, + 162, + 148, + 173 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 148, + 163, + 187, + 173 + ], + "score": 0.88, + "content": "t = 1 : T", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 162, + 201, + 173 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 110, + 172, + 294, + 185 + ], + "spans": [ + { + "bbox": [ + 110, + 173, + 121, + 185 + ], + "score": 1.0, + "content": "6:", + "type": "text" + }, + { + "bbox": [ + 143, + 172, + 294, + 185 + ], + "score": 1.0, + "content": "Update Q network using Equation 10", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 110, + 183, + 288, + 196 + ], + "spans": [ + { + "bbox": [ + 110, + 184, + 121, + 196 + ], + "score": 1.0, + "content": "7:", + "type": "text" + }, + { + "bbox": [ + 143, + 183, + 288, + 196 + ], + "score": 1.0, + "content": "Update the policy using Equation 7", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 110, + 194, + 488, + 208 + ], + "spans": [ + { + "bbox": [ + 110, + 195, + 121, + 207 + ], + "score": 1.0, + "content": "8:", + "type": "text" + }, + { + "bbox": [ + 143, + 194, + 174, + 208 + ], + "score": 1.0, + "content": "Update", + "type": "text" + }, + { + "bbox": [ + 174, + 197, + 182, + 205 + ], + "score": 0.74, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 194, + 289, + 208 + ], + "score": 1.0, + "content": "via dual gradient descent:", + "type": "text" + }, + { + "bbox": [ + 289, + 195, + 488, + 207 + ], + "score": 0.82, + "content": "\\alpha ( s ) \\alpha ( s ) + \\lambda _ { \\alpha } ( \\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { \\theta } ( \\cdot | s ) , \\pi _ { \\beta } ( \\cdot | s ) ) - \\epsilon _ { \\mathrm { K L } } )", + "type": "inline_equation" + } + ], + "index": 9 + }, + { + "bbox": [ + 110, + 205, + 419, + 219 + ], + "spans": [ + { + "bbox": [ + 110, + 206, + 121, + 218 + ], + "score": 1.0, + "content": "9:", + "type": "text" + }, + { + "bbox": [ + 143, + 205, + 174, + 219 + ], + "score": 1.0, + "content": "Update", + "type": "text" + }, + { + "bbox": [ + 174, + 207, + 182, + 217 + ], + "score": 0.83, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 205, + 289, + 219 + ], + "score": 1.0, + "content": "via dual gradient descent:", + "type": "text" + }, + { + "bbox": [ + 289, + 207, + 418, + 218 + ], + "score": 0.78, + "content": "\\beta \\gets \\beta + \\lambda _ { \\beta } ( \\mathcal { H } ( \\pi _ { \\theta } ( \\cdot | s ) ) - \\mathcal { H } _ { 0 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 418, + 205, + 419, + 219 + ], + "score": 0.0, + "content": "", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 107, + 218, + 336, + 231 + ], + "spans": [ + { + "bbox": [ + 107, + 219, + 122, + 231 + ], + "score": 1.0, + "content": "10:", + "type": "text" + }, + { + "bbox": [ + 142, + 218, + 249, + 231 + ], + "score": 1.0, + "content": "Update the target network", + "type": "text" + }, + { + "bbox": [ + 249, + 218, + 336, + 231 + ], + "score": 0.89, + "content": "\\psi ^ { ' } = \\tau \\psi + ( 1 - \\tau ) \\psi ^ { ' }", + "type": "inline_equation" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 229, + 168, + 243 + ], + "spans": [ + { + "bbox": [ + 106, + 230, + 122, + 242 + ], + "score": 1.0, + "content": "11:", + "type": "text" + }, + { + "bbox": [ + 132, + 229, + 168, + 243 + ], + "score": 1.0, + "content": "end for", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 107, + 240, + 158, + 253 + ], + "spans": [ + { + "bbox": [ + 107, + 241, + 126, + 252 + ], + "score": 1.0, + "content": "12:", + "type": "text" + }, + { + "bbox": [ + 120, + 240, + 158, + 253 + ], + "score": 1.0, + "content": "end for", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 108, + 278, + 505, + 301 + ], + "lines": [ + { + "bbox": [ + 106, + 278, + 505, + 291 + ], + "spans": [ + { + "bbox": [ + 106, + 278, + 505, + 291 + ], + "score": 1.0, + "content": "performing policy improvement step simply reduces to minimizing the KL divergence. Inspired", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 288, + 478, + 302 + ], + "spans": [ + { + "bbox": [ + 106, + 288, + 478, + 302 + ], + "score": 1.0, + "content": "from (Gulrajani et al., 2017), we add a gradient penalty term to the policy evaluation step as:", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5 + }, + { + "type": "interline_equation", + "bbox": [ + 117, + 308, + 493, + 349 + ], + "lines": [ + { + "bbox": [ + 117, + 308, + 493, + 349 + ], + "spans": [ + { + "bbox": [ + 117, + 308, + 493, + 349 + ], + "score": 0.92, + "content": "\\begin{array} { r l } & { \\underset { \\psi } { \\operatorname* { m i n } } \\ : \\mathbb { E } _ { ( s , a ) \\sim \\mathcal { D } } ( ( Q _ { \\psi } ( s , a ) - r ( s , a ) + \\gamma \\mathbb { E } _ { a ^ { \\prime } \\sim \\pi a \\theta } Q _ { \\psi ^ { \\prime } } ( s ^ { \\prime } , a ^ { \\prime } ) ) ^ { 2 } } \\\\ & { \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad + \\lambda \\mathbb { E } _ { a ^ { \\prime \\prime } \\sim \\pi \\pi _ { \\theta } ( \\cdot \\vert s ) } ( \\vert \\vert \\nabla _ { a ^ { \\prime \\prime } } Q _ { \\psi } ( s , a ^ { \\prime \\prime } ) \\vert \\vert _ { 2 } f ( \\mathcal { D } _ { K L } ( \\pi _ { \\theta } ( \\cdot \\vert s ) , \\pi _ { \\beta } ( \\cdot \\vert s ) ) - \\epsilon _ { \\mathrm { G P } } ) ) ) } \\end{array}", + "type": "interline_equation", + "image_path": "4e3a265e2cd1ef0e8c1bdb68c6f1a5aaef2facc1de8bdd08761ebaca97066aff.jpg" + } + ] + } + ], + "index": 17, + "virtual_lines": [ + { + "bbox": [ + 117, + 308, + 493, + 321.6666666666667 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 117, + 321.6666666666667, + 493, + 335.33333333333337 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 117, + 335.33333333333337, + 493, + 349.00000000000006 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 366, + 505, + 433 + ], + "lines": [ + { + "bbox": [ + 106, + 365, + 505, + 380 + ], + "spans": [ + { + "bbox": [ + 106, + 365, + 134, + 380 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 369, + 141, + 379 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 365, + 278, + 380 + ], + "score": 1.0, + "content": "is a non-decreasing function and", + "type": "text" + }, + { + "bbox": [ + 279, + 371, + 296, + 379 + ], + "score": 0.79, + "content": "\\epsilon _ { G P }", + "type": "inline_equation" + }, + { + "bbox": [ + 296, + 365, + 505, + 380 + ], + "score": 1.0, + "content": "is the threshold for gradient penalty. In this paper,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 378, + 505, + 390 + ], + "spans": [ + { + "bbox": [ + 106, + 378, + 135, + 389 + ], + "score": 1.0, + "content": "we set", + "type": "text" + }, + { + "bbox": [ + 135, + 380, + 142, + 390 + ], + "score": 0.87, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 378, + 505, + 389 + ], + "score": 1.0, + "content": "to be the Heaviside step function (or indicator). Other variants such as its soft version", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 388, + 505, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 388, + 326, + 402 + ], + "score": 1.0, + "content": "(sigmoid function) is left for future work. Setting", + "type": "text" + }, + { + "bbox": [ + 327, + 390, + 379, + 401 + ], + "score": 0.82, + "content": "\\epsilon _ { G P } ~ = ~ \\epsilon _ { K L }", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 388, + 505, + 402 + ], + "score": 1.0, + "content": "is too conservative because it", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 399, + 503, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 279, + 413 + ], + "score": 1.0, + "content": "prevents generalization. In practice, we set", + "type": "text" + }, + { + "bbox": [ + 280, + 402, + 297, + 411 + ], + "score": 0.83, + "content": "\\epsilon _ { G P }", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 399, + 335, + 413 + ], + "score": 1.0, + "content": "at epoch", + "type": "text" + }, + { + "bbox": [ + 335, + 402, + 340, + 410 + ], + "score": 0.8, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 399, + 363, + 413 + ], + "score": 1.0, + "content": "to be", + "type": "text" + }, + { + "bbox": [ + 363, + 402, + 414, + 412 + ], + "score": 0.86, + "content": "\\mu _ { K L } + \\sigma _ { K L }", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 399, + 445, + 413 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 446, + 403, + 465, + 412 + ], + "score": 0.78, + "content": "\\mu _ { K L }", + "type": "inline_equation" + }, + { + "bbox": [ + 465, + 399, + 484, + 413 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 484, + 405, + 503, + 411 + ], + "score": 0.82, + "content": "\\sigma _ { K L }", + "type": "inline_equation" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 410, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 106, + 410, + 505, + 423 + ], + "score": 1.0, + "content": "is the mean and standard deviation of the KL divergence for all the states in the dataset at epoch", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 107, + 421, + 385, + 434 + ], + "spans": [ + { + "bbox": [ + 107, + 425, + 128, + 433 + ], + "score": 0.89, + "content": "t - 1", + "type": "inline_equation" + }, + { + "bbox": [ + 128, + 421, + 239, + 434 + ], + "score": 1.0, + "content": ". In addition, we found that", + "type": "text" + }, + { + "bbox": [ + 239, + 423, + 272, + 432 + ], + "score": 0.83, + "content": "\\lambda = 0 . 1", + "type": "inline_equation" + }, + { + "bbox": [ + 272, + 421, + 385, + 434 + ], + "score": 1.0, + "content": "works well for all the tasks.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 21.5 + }, + { + "type": "title", + "bbox": [ + 108, + 452, + 211, + 465 + ], + "lines": [ + { + "bbox": [ + 105, + 451, + 213, + 467 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 213, + 467 + ], + "score": 1.0, + "content": "4 RELATED WORK", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 478, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 479, + 504, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 504, + 492 + ], + "score": 1.0, + "content": "We briefly summarize prior works in offline RL and discuss their relationship with our approach.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 490, + 505, + 503 + ], + "spans": [ + { + "bbox": [ + 105, + 490, + 505, + 503 + ], + "score": 1.0, + "content": "As discussed in Section 1, the fundamental challenge in learning from a static data is to avoid", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 501, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 505, + 514 + ], + "score": 1.0, + "content": "out-of-distribution actions (Levine et al., 2020). This requires solving two problems: 1) estima-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 505, + 525 + ], + "score": 1.0, + "content": "tion of behavior policy, 2) quantification of out-of-distribution actions. We follow BCQ (Fujimoto", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 522, + 506, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 506, + 536 + ], + "score": 1.0, + "content": "et al., 2018b), BEAR (Kumar et al., 2019) and BRAC (Wu et al., 2019) by learning the behavior", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 534, + 506, + 547 + ], + "spans": [ + { + "bbox": [ + 104, + 534, + 506, + 547 + ], + "score": 1.0, + "content": "policy using a conditional VAE (Kingma & Welling, 2014). To avoid out-of-distribution actions,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 544, + 506, + 559 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 506, + 559 + ], + "score": 1.0, + "content": "BCQ generates actions in the target values by perturbing the behavior policy. However, this is", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 555, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 506, + 570 + ], + "score": 1.0, + "content": "over-pessimistic in most of the cases. BRAC (Wu et al., 2019) constrains the policy using vari-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 566, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 104, + 566, + 179, + 581 + ], + "score": 1.0, + "content": "ous sample-based", + "type": "text" + }, + { + "bbox": [ + 179, + 568, + 186, + 578 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 566, + 506, + 581 + ], + "score": 1.0, + "content": "-divergence measures including MMD, Wasserstein distance and KL divergence", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 578, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 106, + 578, + 505, + 591 + ], + "score": 1.0, + "content": "with penalized policy improvement or policy evaluation. BEAR (Kumar et al., 2019) is an instance", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 590, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 106, + 590, + 505, + 601 + ], + "score": 1.0, + "content": "of BRAC with penalized policy improvement using MMD (Gretton et al., 2007). Sample-based", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 600, + 506, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 506, + 612 + ], + "score": 1.0, + "content": "estimation is computationally expensive and suffers from high variance. In contrast, our method", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 611, + 506, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 506, + 624 + ], + "score": 1.0, + "content": "uses an analytical upper-bound of the KL divergence to constrain the distance between the learned", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 621, + 506, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 506, + 635 + ], + "score": 1.0, + "content": "policy and the behavior policy. It is both computationally efficient and has low variance. (Siegel", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 633, + 506, + 645 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 506, + 645 + ], + "score": 1.0, + "content": "et al., 2020) solves trust-region objective instead of using penalty. CQL (Kumar et al., 2020) avoids", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 644, + 506, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 644, + 506, + 657 + ], + "score": 1.0, + "content": "estimating the behavior policy by learning a conservative Q function that lower-bounds its true", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 655, + 506, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 506, + 667 + ], + "score": 1.0, + "content": "value. Hyperparameter search is another challenging problem in offline RL. (Lee et al., 2020) uses", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "a gradient-based optimization of the hyperparameter using held-out data. MOPO (Yu et al., 2020)", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "score": 1.0, + "content": "follows MBPO Janner et al. (2019) with additional reward penalty on unreliable model-generated", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "transitions. MBOP (Argenson & Dulac-Arnold, 2020) learns the dynamics mode, the behavior", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "policy and a truncated value function to perform online planning. (Kidambi et al., 2020) learns a", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 710, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 721 + ], + "score": 1.0, + "content": "surrogate MDP using the dataset, such that taking out-of-distribution actions transit to the terminal", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 720, + 473, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 473, + 733 + ], + "score": 1.0, + "content": "state. The out-of-distribution actions are detected using the agreement of model ensembles.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 37 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "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": "title", + "bbox": [ + 107, + 81, + 379, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 380, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 380, + 94 + ], + "score": 1.0, + "content": "Algorithm 1 BRAC+: Improved Behavior Regularized Actor Critic", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "index", + "bbox": [ + 110, + 99, + 499, + 254 + ], + "lines": [ + { + "bbox": [ + 109, + 97, + 502, + 114 + ], + "spans": [ + { + "bbox": [ + 109, + 97, + 232, + 114 + ], + "score": 1.0, + "content": "1: Train the behavior policy", + "type": "text" + }, + { + "bbox": [ + 232, + 102, + 244, + 113 + ], + "score": 0.84, + "content": "\\pi _ { \\beta }", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 97, + 338, + 114 + ], + "score": 1.0, + "content": "on the offline dataset", + "type": "text" + }, + { + "bbox": [ + 339, + 99, + 443, + 113 + ], + "score": 0.91, + "content": "\\mathcal { D } = \\{ ( s _ { i } , a _ { i } , r _ { i } , s _ { i } ^ { ' } ) \\} _ { i = 1 } ^ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 443, + 97, + 502, + 114 + ], + "score": 1.0, + "content": "via maximum", + "type": "text" + } + ], + "index": 1, + "is_list_start_line": true + }, + { + "bbox": [ + 120, + 110, + 363, + 131 + ], + "spans": [ + { + "bbox": [ + 120, + 110, + 212, + 131 + ], + "score": 1.0, + "content": "likelihood estimation:", + "type": "text" + }, + { + "bbox": [ + 213, + 111, + 363, + 127 + ], + "score": 0.87, + "content": "\\begin{array} { r } { \\pi _ { \\beta } = \\arg \\operatorname* { m a x } _ { \\pi _ { \\beta } } \\sum _ { i = 1 } ^ { N } \\log \\pi _ { \\beta } ( a _ { i } | s _ { i } ) } \\end{array}", + "type": "inline_equation" + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 109, + 124, + 330, + 141 + ], + "spans": [ + { + "bbox": [ + 109, + 124, + 205, + 141 + ], + "score": 1.0, + "content": "2: Train initial policy:", + "type": "text" + }, + { + "bbox": [ + 205, + 128, + 330, + 139 + ], + "score": 0.86, + "content": "\\begin{array} { r } { \\pi _ { \\theta } = \\arg \\operatorname* { m i n } _ { \\pi _ { \\theta } \\in \\Pi } \\mathcal { D } _ { \\mathrm { K L } } ( \\pi , \\pi _ { \\beta } ) } \\end{array}", + "type": "inline_equation" + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 111, + 137, + 480, + 153 + ], + "spans": [ + { + "bbox": [ + 111, + 137, + 220, + 153 + ], + "score": 1.0, + "content": "3: Train initial Q network:", + "type": "text" + }, + { + "bbox": [ + 220, + 139, + 480, + 153 + ], + "score": 0.81, + "content": "\\begin{array} { r } { Q _ { \\psi } = \\arg \\operatorname* { m i n } _ { \\psi } [ ( Q _ { \\psi } ( s , a ) - ( r ( s , a ) + \\gamma \\mathbb { E } _ { a ^ { \\prime } \\sim \\pi _ { \\theta } } Q _ { \\psi ^ { \\prime } } ( s ^ { \\prime } , a ^ { \\prime } ) ) ) ] ^ { 2 } } \\end{array}", + "type": "inline_equation" + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 110, + 151, + 194, + 162 + ], + "spans": [ + { + "bbox": [ + 110, + 151, + 138, + 162 + ], + "score": 1.0, + "content": "4: for", + "type": "text" + }, + { + "bbox": [ + 138, + 151, + 179, + 162 + ], + "score": 0.87, + "content": "e = 1 : E", + "type": "inline_equation" + }, + { + "bbox": [ + 179, + 151, + 194, + 162 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 110, + 162, + 201, + 174 + ], + "spans": [ + { + "bbox": [ + 110, + 162, + 121, + 174 + ], + "score": 1.0, + "content": "5:", + "type": "text" + }, + { + "bbox": [ + 132, + 162, + 148, + 173 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 148, + 163, + 187, + 173 + ], + "score": 0.88, + "content": "t = 1 : T", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 162, + 201, + 173 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 110, + 172, + 294, + 185 + ], + "spans": [ + { + "bbox": [ + 110, + 173, + 121, + 185 + ], + "score": 1.0, + "content": "6:", + "type": "text" + }, + { + "bbox": [ + 143, + 172, + 294, + 185 + ], + "score": 1.0, + "content": "Update Q network using Equation 10", + "type": "text" + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 110, + 183, + 288, + 196 + ], + "spans": [ + { + "bbox": [ + 110, + 184, + 121, + 196 + ], + "score": 1.0, + "content": "7:", + "type": "text" + }, + { + "bbox": [ + 143, + 183, + 288, + 196 + ], + "score": 1.0, + "content": "Update the policy using Equation 7", + "type": "text" + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 110, + 194, + 488, + 208 + ], + "spans": [ + { + "bbox": [ + 110, + 195, + 121, + 207 + ], + "score": 1.0, + "content": "8:", + "type": "text" + }, + { + "bbox": [ + 143, + 194, + 174, + 208 + ], + "score": 1.0, + "content": "Update", + "type": "text" + }, + { + "bbox": [ + 174, + 197, + 182, + 205 + ], + "score": 0.74, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 194, + 289, + 208 + ], + "score": 1.0, + "content": "via dual gradient descent:", + "type": "text" + }, + { + "bbox": [ + 289, + 195, + 488, + 207 + ], + "score": 0.82, + "content": "\\alpha ( s ) \\alpha ( s ) + \\lambda _ { \\alpha } ( \\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { \\theta } ( \\cdot | s ) , \\pi _ { \\beta } ( \\cdot | s ) ) - \\epsilon _ { \\mathrm { K L } } )", + "type": "inline_equation" + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 110, + 205, + 419, + 219 + ], + "spans": [ + { + "bbox": [ + 110, + 206, + 121, + 218 + ], + "score": 1.0, + "content": "9:", + "type": "text" + }, + { + "bbox": [ + 143, + 205, + 174, + 219 + ], + "score": 1.0, + "content": "Update", + "type": "text" + }, + { + "bbox": [ + 174, + 207, + 182, + 217 + ], + "score": 0.83, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 205, + 289, + 219 + ], + "score": 1.0, + "content": "via dual gradient descent:", + "type": "text" + }, + { + "bbox": [ + 289, + 207, + 418, + 218 + ], + "score": 0.78, + "content": "\\beta \\gets \\beta + \\lambda _ { \\beta } ( \\mathcal { H } ( \\pi _ { \\theta } ( \\cdot | s ) ) - \\mathcal { H } _ { 0 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 418, + 205, + 419, + 219 + ], + "score": 0.0, + "content": "", + "type": "text" + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 107, + 218, + 336, + 231 + ], + "spans": [ + { + "bbox": [ + 107, + 219, + 122, + 231 + ], + "score": 1.0, + "content": "10:", + "type": "text" + }, + { + "bbox": [ + 142, + 218, + 249, + 231 + ], + "score": 1.0, + "content": "Update the target network", + "type": "text" + }, + { + "bbox": [ + 249, + 218, + 336, + 231 + ], + "score": 0.89, + "content": "\\psi ^ { ' } = \\tau \\psi + ( 1 - \\tau ) \\psi ^ { ' }", + "type": "inline_equation" + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 106, + 229, + 168, + 243 + ], + "spans": [ + { + "bbox": [ + 106, + 230, + 122, + 242 + ], + "score": 1.0, + "content": "11:", + "type": "text" + }, + { + "bbox": [ + 132, + 229, + 168, + 243 + ], + "score": 1.0, + "content": "end for", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 107, + 240, + 158, + 253 + ], + "spans": [ + { + "bbox": [ + 107, + 241, + 126, + 252 + ], + "score": 1.0, + "content": "12:", + "type": "text" + }, + { + "bbox": [ + 120, + 240, + 158, + 253 + ], + "score": 1.0, + "content": "end for", + "type": "text" + } + ], + "index": 13, + "is_list_start_line": true + } + ], + "index": 7, + "bbox_fs": [ + 106, + 97, + 502, + 253 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 278, + 505, + 301 + ], + "lines": [ + { + "bbox": [ + 106, + 278, + 505, + 291 + ], + "spans": [ + { + "bbox": [ + 106, + 278, + 505, + 291 + ], + "score": 1.0, + "content": "performing policy improvement step simply reduces to minimizing the KL divergence. Inspired", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 288, + 478, + 302 + ], + "spans": [ + { + "bbox": [ + 106, + 288, + 478, + 302 + ], + "score": 1.0, + "content": "from (Gulrajani et al., 2017), we add a gradient penalty term to the policy evaluation step as:", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5, + "bbox_fs": [ + 106, + 278, + 505, + 302 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 117, + 308, + 493, + 349 + ], + "lines": [ + { + "bbox": [ + 117, + 308, + 493, + 349 + ], + "spans": [ + { + "bbox": [ + 117, + 308, + 493, + 349 + ], + "score": 0.92, + "content": "\\begin{array} { r l } & { \\underset { \\psi } { \\operatorname* { m i n } } \\ : \\mathbb { E } _ { ( s , a ) \\sim \\mathcal { D } } ( ( Q _ { \\psi } ( s , a ) - r ( s , a ) + \\gamma \\mathbb { E } _ { a ^ { \\prime } \\sim \\pi a \\theta } Q _ { \\psi ^ { \\prime } } ( s ^ { \\prime } , a ^ { \\prime } ) ) ^ { 2 } } \\\\ & { \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad + \\lambda \\mathbb { E } _ { a ^ { \\prime \\prime } \\sim \\pi \\pi _ { \\theta } ( \\cdot \\vert s ) } ( \\vert \\vert \\nabla _ { a ^ { \\prime \\prime } } Q _ { \\psi } ( s , a ^ { \\prime \\prime } ) \\vert \\vert _ { 2 } f ( \\mathcal { D } _ { K L } ( \\pi _ { \\theta } ( \\cdot \\vert s ) , \\pi _ { \\beta } ( \\cdot \\vert s ) ) - \\epsilon _ { \\mathrm { G P } } ) ) ) } \\end{array}", + "type": "interline_equation", + "image_path": "4e3a265e2cd1ef0e8c1bdb68c6f1a5aaef2facc1de8bdd08761ebaca97066aff.jpg" + } + ] + } + ], + "index": 17, + "virtual_lines": [ + { + "bbox": [ + 117, + 308, + 493, + 321.6666666666667 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 117, + 321.6666666666667, + 493, + 335.33333333333337 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 117, + 335.33333333333337, + 493, + 349.00000000000006 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 366, + 505, + 433 + ], + "lines": [ + { + "bbox": [ + 106, + 365, + 505, + 380 + ], + "spans": [ + { + "bbox": [ + 106, + 365, + 134, + 380 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 369, + 141, + 379 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 365, + 278, + 380 + ], + "score": 1.0, + "content": "is a non-decreasing function and", + "type": "text" + }, + { + "bbox": [ + 279, + 371, + 296, + 379 + ], + "score": 0.79, + "content": "\\epsilon _ { G P }", + "type": "inline_equation" + }, + { + "bbox": [ + 296, + 365, + 505, + 380 + ], + "score": 1.0, + "content": "is the threshold for gradient penalty. In this paper,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 378, + 505, + 390 + ], + "spans": [ + { + "bbox": [ + 106, + 378, + 135, + 389 + ], + "score": 1.0, + "content": "we set", + "type": "text" + }, + { + "bbox": [ + 135, + 380, + 142, + 390 + ], + "score": 0.87, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 378, + 505, + 389 + ], + "score": 1.0, + "content": "to be the Heaviside step function (or indicator). Other variants such as its soft version", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 388, + 505, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 388, + 326, + 402 + ], + "score": 1.0, + "content": "(sigmoid function) is left for future work. Setting", + "type": "text" + }, + { + "bbox": [ + 327, + 390, + 379, + 401 + ], + "score": 0.82, + "content": "\\epsilon _ { G P } ~ = ~ \\epsilon _ { K L }", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 388, + 505, + 402 + ], + "score": 1.0, + "content": "is too conservative because it", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 399, + 503, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 279, + 413 + ], + "score": 1.0, + "content": "prevents generalization. In practice, we set", + "type": "text" + }, + { + "bbox": [ + 280, + 402, + 297, + 411 + ], + "score": 0.83, + "content": "\\epsilon _ { G P }", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 399, + 335, + 413 + ], + "score": 1.0, + "content": "at epoch", + "type": "text" + }, + { + "bbox": [ + 335, + 402, + 340, + 410 + ], + "score": 0.8, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 399, + 363, + 413 + ], + "score": 1.0, + "content": "to be", + "type": "text" + }, + { + "bbox": [ + 363, + 402, + 414, + 412 + ], + "score": 0.86, + "content": "\\mu _ { K L } + \\sigma _ { K L }", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 399, + 445, + 413 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 446, + 403, + 465, + 412 + ], + "score": 0.78, + "content": "\\mu _ { K L }", + "type": "inline_equation" + }, + { + "bbox": [ + 465, + 399, + 484, + 413 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 484, + 405, + 503, + 411 + ], + "score": 0.82, + "content": "\\sigma _ { K L }", + "type": "inline_equation" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 410, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 106, + 410, + 505, + 423 + ], + "score": 1.0, + "content": "is the mean and standard deviation of the KL divergence for all the states in the dataset at epoch", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 107, + 421, + 385, + 434 + ], + "spans": [ + { + "bbox": [ + 107, + 425, + 128, + 433 + ], + "score": 0.89, + "content": "t - 1", + "type": "inline_equation" + }, + { + "bbox": [ + 128, + 421, + 239, + 434 + ], + "score": 1.0, + "content": ". In addition, we found that", + "type": "text" + }, + { + "bbox": [ + 239, + 423, + 272, + 432 + ], + "score": 0.83, + "content": "\\lambda = 0 . 1", + "type": "inline_equation" + }, + { + "bbox": [ + 272, + 421, + 385, + 434 + ], + "score": 1.0, + "content": "works well for all the tasks.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 365, + 505, + 434 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 452, + 211, + 465 + ], + "lines": [ + { + "bbox": [ + 105, + 451, + 213, + 467 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 213, + 467 + ], + "score": 1.0, + "content": "4 RELATED WORK", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 478, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 479, + 504, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 504, + 492 + ], + "score": 1.0, + "content": "We briefly summarize prior works in offline RL and discuss their relationship with our approach.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 490, + 505, + 503 + ], + "spans": [ + { + "bbox": [ + 105, + 490, + 505, + 503 + ], + "score": 1.0, + "content": "As discussed in Section 1, the fundamental challenge in learning from a static data is to avoid", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 501, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 505, + 514 + ], + "score": 1.0, + "content": "out-of-distribution actions (Levine et al., 2020). This requires solving two problems: 1) estima-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 505, + 525 + ], + "score": 1.0, + "content": "tion of behavior policy, 2) quantification of out-of-distribution actions. We follow BCQ (Fujimoto", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 522, + 506, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 506, + 536 + ], + "score": 1.0, + "content": "et al., 2018b), BEAR (Kumar et al., 2019) and BRAC (Wu et al., 2019) by learning the behavior", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 534, + 506, + 547 + ], + "spans": [ + { + "bbox": [ + 104, + 534, + 506, + 547 + ], + "score": 1.0, + "content": "policy using a conditional VAE (Kingma & Welling, 2014). To avoid out-of-distribution actions,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 544, + 506, + 559 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 506, + 559 + ], + "score": 1.0, + "content": "BCQ generates actions in the target values by perturbing the behavior policy. However, this is", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 555, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 506, + 570 + ], + "score": 1.0, + "content": "over-pessimistic in most of the cases. BRAC (Wu et al., 2019) constrains the policy using vari-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 566, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 104, + 566, + 179, + 581 + ], + "score": 1.0, + "content": "ous sample-based", + "type": "text" + }, + { + "bbox": [ + 179, + 568, + 186, + 578 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 566, + 506, + 581 + ], + "score": 1.0, + "content": "-divergence measures including MMD, Wasserstein distance and KL divergence", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 578, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 106, + 578, + 505, + 591 + ], + "score": 1.0, + "content": "with penalized policy improvement or policy evaluation. BEAR (Kumar et al., 2019) is an instance", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 590, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 106, + 590, + 505, + 601 + ], + "score": 1.0, + "content": "of BRAC with penalized policy improvement using MMD (Gretton et al., 2007). Sample-based", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 600, + 506, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 506, + 612 + ], + "score": 1.0, + "content": "estimation is computationally expensive and suffers from high variance. In contrast, our method", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 611, + 506, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 506, + 624 + ], + "score": 1.0, + "content": "uses an analytical upper-bound of the KL divergence to constrain the distance between the learned", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 621, + 506, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 506, + 635 + ], + "score": 1.0, + "content": "policy and the behavior policy. It is both computationally efficient and has low variance. (Siegel", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 633, + 506, + 645 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 506, + 645 + ], + "score": 1.0, + "content": "et al., 2020) solves trust-region objective instead of using penalty. CQL (Kumar et al., 2020) avoids", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 644, + 506, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 644, + 506, + 657 + ], + "score": 1.0, + "content": "estimating the behavior policy by learning a conservative Q function that lower-bounds its true", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 655, + 506, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 506, + 667 + ], + "score": 1.0, + "content": "value. Hyperparameter search is another challenging problem in offline RL. (Lee et al., 2020) uses", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "a gradient-based optimization of the hyperparameter using held-out data. MOPO (Yu et al., 2020)", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "score": 1.0, + "content": "follows MBPO Janner et al. (2019) with additional reward penalty on unreliable model-generated", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "transitions. MBOP (Argenson & Dulac-Arnold, 2020) learns the dynamics mode, the behavior", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "policy and a truncated value function to perform online planning. (Kidambi et al., 2020) learns a", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 710, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 721 + ], + "score": 1.0, + "content": "surrogate MDP using the dataset, such that taking out-of-distribution actions transit to the terminal", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 720, + 473, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 473, + 733 + ], + "score": 1.0, + "content": "state. The out-of-distribution actions are detected using the agreement of model ensembles.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 37, + "bbox_fs": [ + 104, + 479, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 200, + 93 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 201, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 201, + 96 + ], + "score": 1.0, + "content": "5 EXPERIMENTS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 106, + 107, + 505, + 281 + ], + "lines": [ + { + "bbox": [ + 106, + 107, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 106, + 107, + 505, + 119 + ], + "score": 1.0, + "content": "Our experiments1 aim to answer the following questions: 1) How does the performance of our", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 117, + 505, + 129 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 505, + 129 + ], + "score": 1.0, + "content": "improvements compare with state-of-the-art model-free and model-based offline RL methods? 2)", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 127, + 505, + 141 + ], + "spans": [ + { + "bbox": [ + 105, + 127, + 505, + 141 + ], + "score": 1.0, + "content": "How does the use of analytical variational upper bound on KL divergence for regularization term", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 140, + 505, + 152 + ], + "spans": [ + { + "bbox": [ + 106, + 140, + 505, + 152 + ], + "score": 1.0, + "content": "compare with sampled-based MMD? 3) How does the state-dependent Lagrange multiplier based", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 151, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 505, + 162 + ], + "score": 1.0, + "content": "regularization (state-wise regularizor) compare with global policy regularization? 4) Does the gradi-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 162, + 505, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 162, + 505, + 174 + ], + "score": 1.0, + "content": "ent penalized policy evaluation improve the stability during the training? To answer these questions,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 173, + 504, + 184 + ], + "spans": [ + { + "bbox": [ + 106, + 173, + 504, + 184 + ], + "score": 1.0, + "content": "we evaluate our methods on a subset of the D4RL (Fu et al., 2020) benchmark. We consider three", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 184, + 504, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 184, + 504, + 195 + ], + "score": 1.0, + "content": "locomotion tasks (hopper, walker2d, and halfcheetah) and four types of datasets: 1) random (rand):", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 194, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 194, + 505, + 207 + ], + "score": 1.0, + "content": "collect the interactions of a run of random policy for 1M steps to create the dataset, 2) medium", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 205, + 505, + 218 + ], + "spans": [ + { + "bbox": [ + 106, + 205, + 505, + 218 + ], + "score": 1.0, + "content": "(med): collect the interactions of a run of medium quality policy for 1M steps as the dataset, 3)", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 104, + 215, + 506, + 230 + ], + "spans": [ + { + "bbox": [ + 104, + 215, + 506, + 230 + ], + "score": 1.0, + "content": "medium-expert (med-exp): run a medium quality policy and an expert quality policy for 1M steps,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 227, + 505, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 227, + 505, + 239 + ], + "score": 1.0, + "content": "respectively, and combine their interactions to create the dataset, 4) mixed (medium-replay): train", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 239, + 506, + 251 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 506, + 251 + ], + "score": 1.0, + "content": "a policy using SAC (Haarnoja et al., 2018a) until the performance of the learned policy exceeds a", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 249, + 505, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 249, + 505, + 261 + ], + "score": 1.0, + "content": "pre-determined threshold, and take the replay buffer as the dataset. In addition, we consider more", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 259, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 505, + 273 + ], + "score": 1.0, + "content": "complex Adroit tasks (Rajeswaran et al., 2018) that requires controlling a 24-DoF robotic hand,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 272, + 297, + 283 + ], + "spans": [ + { + "bbox": [ + 106, + 272, + 297, + 283 + ], + "score": 1.0, + "content": "using limited data from human demonstrations.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 107, + 288, + 505, + 387 + ], + "lines": [ + { + "bbox": [ + 106, + 288, + 506, + 301 + ], + "spans": [ + { + "bbox": [ + 106, + 288, + 506, + 301 + ], + "score": 1.0, + "content": "We compare against state-of-the-art model-free and model-based baselines, including behavior", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 299, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 299, + 505, + 312 + ], + "score": 1.0, + "content": "cloning, BEAR (Kumar et al., 2019) that constrains the learned policy within the support of the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 310, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 105, + 310, + 505, + 323 + ], + "score": 1.0, + "content": "behavior policy using sampled MMD, BRAC-p/v (Wu et al., 2019) that constrains the learned pol-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 321, + 505, + 334 + ], + "spans": [ + { + "bbox": [ + 105, + 321, + 400, + 334 + ], + "score": 1.0, + "content": "icy within the support of the behavior policy using various sample-based", + "type": "text" + }, + { + "bbox": [ + 400, + 322, + 407, + 333 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 321, + 505, + 334 + ], + "score": 1.0, + "content": "-divergences to penalize", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 331, + 506, + 346 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 362, + 346 + ], + "score": 1.0, + "content": "either the policy improvement (p) or the policy evaluation (v),", + "type": "text" + }, + { + "bbox": [ + 363, + 332, + 399, + 343 + ], + "score": 0.3, + "content": "\\operatorname { C Q L } ( { \\mathcal { H } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 331, + 506, + 346 + ], + "score": 1.0, + "content": "(Kumar et al., 2020) that", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 341, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 104, + 341, + 505, + 357 + ], + "score": 1.0, + "content": "learns a Q function that lower-bounds its true value. We also compare against model-based ap-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 353, + 506, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 506, + 367 + ], + "score": 1.0, + "content": "proaches including MOPO (Yu et al., 2020) that follows MBPO (Janner et al., 2019) with additional", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 364, + 505, + 378 + ], + "spans": [ + { + "bbox": [ + 105, + 364, + 505, + 378 + ], + "score": 1.0, + "content": "reward penalties and MBOP (Argenson & Dulac-Arnold, 2020) that learns an offline model to per-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 375, + 196, + 390 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 196, + 390 + ], + "score": 1.0, + "content": "form online planning.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 21 + }, + { + "type": "title", + "bbox": [ + 107, + 402, + 235, + 413 + ], + "lines": [ + { + "bbox": [ + 105, + 401, + 237, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 237, + 415 + ], + "score": 1.0, + "content": "5.1 COMPARATIVE RESULTS", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "table", + "bbox": [ + 106, + 483, + 510, + 654 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 426, + 505, + 482 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 426, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 106, + 426, + 505, + 439 + ], + "score": 1.0, + "content": "Table 1: Results for OpenAI gym (Brockman et al., 2016) environments in the D4RL (Fu et al.,", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 435, + 505, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 505, + 451 + ], + "score": 1.0, + "content": "2020) datasets. For each task, we train for 1 million gradient steps and report the performance by", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 448, + 506, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 506, + 461 + ], + "score": 1.0, + "content": "running the policy obtained at the last epoch of the training for 100 episodes, averaged over 4 random", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 459, + 505, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 505, + 473 + ], + "score": 1.0, + "content": "seeds with standard deviation. Each number is the normalized score as proposed in (Fu et al., 2020).", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 470, + 352, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 352, + 483 + ], + "score": 1.0, + "content": "Please refer to (Fu et al., 2020) for results on more baselines.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29 + }, + { + "type": "table_body", + "bbox": [ + 106, + 483, + 510, + 654 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 483, + 510, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 483, + 510, + 654 + ], + "score": 0.986, + "html": "
Task NameModel-FreeModel-Based
BEARBRAC-p/vCQL(H)BRAC+ (Ours)MOPOMBOP
halfcheetah-rand25.124.1/31.235.426.4±1.031.9±2.86.3±4.0
walker2d-rand7.3-0.2/1.97.016.7± 2.313.0±2.68.1± 5.5
hopper-rand11.411.0/12.210.812.5±0.313.3±1.610.8± 0.3
halfcheetah-med41.743.8/46.344.446.6±0.640.2± 2.744.6±0.8
walker2d-med59.177.5/81.179.275.1±3.514.0±10.141.0 ± 29.4
hopper-med52.132.7/31.158.053.2±3.126.5±3.748.8± 26.8
halfcheetah-med-exp53.444.2/41.962.461.2±2.857.9± 24.8105.9± 17.8
walker2d-med-exp40.176.9/81.698.795.3± 5.955.0± 19.170.2 ± 36.2
hopper-med-exp96.31.9/0.8111.0112.9±0.151.7±42.955.1 ± 44.3
halfcheetah-mixed38.645.4/47.746.246.1±0.254.0±2.642.3 ± 0.9
walker2d-mixed19.2-0.3/0.926.739.0±4.642.7±8.39.7 ± 5.3
hopper-mixed33.70.6/0.648.672.7±18.992.5±6.312.4 ± 5.8
", + "type": "table", + "image_path": "47dc016865358263b6ae66c8ae08e95fd81d867921262b7ad312a7ddce3dc217.jpg" + } + ] + } + ], + "index": 33, + "virtual_lines": [ + { + "bbox": [ + 106, + 483, + 510, + 540.0 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 106, + 540.0, + 510, + 597.0 + ], + "spans": [], + "index": 33 + }, + { + "bbox": [ + 106, + 597.0, + 510, + 654.0 + ], + "spans": [], + "index": 34 + } + ] + } + ], + "index": 31.0 + }, + { + "type": "text", + "bbox": [ + 108, + 677, + 505, + 711 + ], + "lines": [ + { + "bbox": [ + 106, + 678, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 678, + 505, + 690 + ], + "score": 1.0, + "content": "Performance on multi-modal datasets We first compare the performance on multi-modal", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 689, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 505, + 701 + ], + "score": 1.0, + "content": "datasets i.e. med-exp and mixed datasets. Results shown in Table 1 suggest that our method outper-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 712 + ], + "score": 1.0, + "content": "forms various model-free baselines on most of the multi-modal datasets, especially on hopper-mix", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 119, + 722, + 369, + 732 + ], + "lines": [ + { + "bbox": [ + 119, + 720, + 370, + 733 + ], + "spans": [ + { + "bbox": [ + 119, + 720, + 370, + 733 + ], + "score": 1.0, + "content": "1Our code will be released at https://github.com/xxx/xxx.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 310, + 762 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 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 2021", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 200, + 93 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 201, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 201, + 96 + ], + "score": 1.0, + "content": "5 EXPERIMENTS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 106, + 107, + 505, + 281 + ], + "lines": [ + { + "bbox": [ + 106, + 107, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 106, + 107, + 505, + 119 + ], + "score": 1.0, + "content": "Our experiments1 aim to answer the following questions: 1) How does the performance of our", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 117, + 505, + 129 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 505, + 129 + ], + "score": 1.0, + "content": "improvements compare with state-of-the-art model-free and model-based offline RL methods? 2)", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 127, + 505, + 141 + ], + "spans": [ + { + "bbox": [ + 105, + 127, + 505, + 141 + ], + "score": 1.0, + "content": "How does the use of analytical variational upper bound on KL divergence for regularization term", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 140, + 505, + 152 + ], + "spans": [ + { + "bbox": [ + 106, + 140, + 505, + 152 + ], + "score": 1.0, + "content": "compare with sampled-based MMD? 3) How does the state-dependent Lagrange multiplier based", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 151, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 505, + 162 + ], + "score": 1.0, + "content": "regularization (state-wise regularizor) compare with global policy regularization? 4) Does the gradi-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 162, + 505, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 162, + 505, + 174 + ], + "score": 1.0, + "content": "ent penalized policy evaluation improve the stability during the training? To answer these questions,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 173, + 504, + 184 + ], + "spans": [ + { + "bbox": [ + 106, + 173, + 504, + 184 + ], + "score": 1.0, + "content": "we evaluate our methods on a subset of the D4RL (Fu et al., 2020) benchmark. We consider three", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 184, + 504, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 184, + 504, + 195 + ], + "score": 1.0, + "content": "locomotion tasks (hopper, walker2d, and halfcheetah) and four types of datasets: 1) random (rand):", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 194, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 194, + 505, + 207 + ], + "score": 1.0, + "content": "collect the interactions of a run of random policy for 1M steps to create the dataset, 2) medium", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 205, + 505, + 218 + ], + "spans": [ + { + "bbox": [ + 106, + 205, + 505, + 218 + ], + "score": 1.0, + "content": "(med): collect the interactions of a run of medium quality policy for 1M steps as the dataset, 3)", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 104, + 215, + 506, + 230 + ], + "spans": [ + { + "bbox": [ + 104, + 215, + 506, + 230 + ], + "score": 1.0, + "content": "medium-expert (med-exp): run a medium quality policy and an expert quality policy for 1M steps,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 227, + 505, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 227, + 505, + 239 + ], + "score": 1.0, + "content": "respectively, and combine their interactions to create the dataset, 4) mixed (medium-replay): train", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 239, + 506, + 251 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 506, + 251 + ], + "score": 1.0, + "content": "a policy using SAC (Haarnoja et al., 2018a) until the performance of the learned policy exceeds a", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 249, + 505, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 249, + 505, + 261 + ], + "score": 1.0, + "content": "pre-determined threshold, and take the replay buffer as the dataset. In addition, we consider more", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 259, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 505, + 273 + ], + "score": 1.0, + "content": "complex Adroit tasks (Rajeswaran et al., 2018) that requires controlling a 24-DoF robotic hand,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 272, + 297, + 283 + ], + "spans": [ + { + "bbox": [ + 106, + 272, + 297, + 283 + ], + "score": 1.0, + "content": "using limited data from human demonstrations.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 8.5, + "bbox_fs": [ + 104, + 107, + 506, + 283 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 288, + 505, + 387 + ], + "lines": [ + { + "bbox": [ + 106, + 288, + 506, + 301 + ], + "spans": [ + { + "bbox": [ + 106, + 288, + 506, + 301 + ], + "score": 1.0, + "content": "We compare against state-of-the-art model-free and model-based baselines, including behavior", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 299, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 299, + 505, + 312 + ], + "score": 1.0, + "content": "cloning, BEAR (Kumar et al., 2019) that constrains the learned policy within the support of the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 310, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 105, + 310, + 505, + 323 + ], + "score": 1.0, + "content": "behavior policy using sampled MMD, BRAC-p/v (Wu et al., 2019) that constrains the learned pol-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 321, + 505, + 334 + ], + "spans": [ + { + "bbox": [ + 105, + 321, + 400, + 334 + ], + "score": 1.0, + "content": "icy within the support of the behavior policy using various sample-based", + "type": "text" + }, + { + "bbox": [ + 400, + 322, + 407, + 333 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 321, + 505, + 334 + ], + "score": 1.0, + "content": "-divergences to penalize", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 331, + 506, + 346 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 362, + 346 + ], + "score": 1.0, + "content": "either the policy improvement (p) or the policy evaluation (v),", + "type": "text" + }, + { + "bbox": [ + 363, + 332, + 399, + 343 + ], + "score": 0.3, + "content": "\\operatorname { C Q L } ( { \\mathcal { H } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 331, + 506, + 346 + ], + "score": 1.0, + "content": "(Kumar et al., 2020) that", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 341, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 104, + 341, + 505, + 357 + ], + "score": 1.0, + "content": "learns a Q function that lower-bounds its true value. We also compare against model-based ap-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 353, + 506, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 506, + 367 + ], + "score": 1.0, + "content": "proaches including MOPO (Yu et al., 2020) that follows MBPO (Janner et al., 2019) with additional", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 364, + 505, + 378 + ], + "spans": [ + { + "bbox": [ + 105, + 364, + 505, + 378 + ], + "score": 1.0, + "content": "reward penalties and MBOP (Argenson & Dulac-Arnold, 2020) that learns an offline model to per-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 375, + 196, + 390 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 196, + 390 + ], + "score": 1.0, + "content": "form online planning.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 21, + "bbox_fs": [ + 104, + 288, + 506, + 390 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 402, + 235, + 413 + ], + "lines": [ + { + "bbox": [ + 105, + 401, + 237, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 237, + 415 + ], + "score": 1.0, + "content": "5.1 COMPARATIVE RESULTS", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "table", + "bbox": [ + 106, + 483, + 510, + 654 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 426, + 505, + 482 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 426, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 106, + 426, + 505, + 439 + ], + "score": 1.0, + "content": "Table 1: Results for OpenAI gym (Brockman et al., 2016) environments in the D4RL (Fu et al.,", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 435, + 505, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 505, + 451 + ], + "score": 1.0, + "content": "2020) datasets. For each task, we train for 1 million gradient steps and report the performance by", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 448, + 506, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 506, + 461 + ], + "score": 1.0, + "content": "running the policy obtained at the last epoch of the training for 100 episodes, averaged over 4 random", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 459, + 505, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 505, + 473 + ], + "score": 1.0, + "content": "seeds with standard deviation. Each number is the normalized score as proposed in (Fu et al., 2020).", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 470, + 352, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 352, + 483 + ], + "score": 1.0, + "content": "Please refer to (Fu et al., 2020) for results on more baselines.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29 + }, + { + "type": "table_body", + "bbox": [ + 106, + 483, + 510, + 654 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 483, + 510, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 483, + 510, + 654 + ], + "score": 0.986, + "html": "
Task NameModel-FreeModel-Based
BEARBRAC-p/vCQL(H)BRAC+ (Ours)MOPOMBOP
halfcheetah-rand25.124.1/31.235.426.4±1.031.9±2.86.3±4.0
walker2d-rand7.3-0.2/1.97.016.7± 2.313.0±2.68.1± 5.5
hopper-rand11.411.0/12.210.812.5±0.313.3±1.610.8± 0.3
halfcheetah-med41.743.8/46.344.446.6±0.640.2± 2.744.6±0.8
walker2d-med59.177.5/81.179.275.1±3.514.0±10.141.0 ± 29.4
hopper-med52.132.7/31.158.053.2±3.126.5±3.748.8± 26.8
halfcheetah-med-exp53.444.2/41.962.461.2±2.857.9± 24.8105.9± 17.8
walker2d-med-exp40.176.9/81.698.795.3± 5.955.0± 19.170.2 ± 36.2
hopper-med-exp96.31.9/0.8111.0112.9±0.151.7±42.955.1 ± 44.3
halfcheetah-mixed38.645.4/47.746.246.1±0.254.0±2.642.3 ± 0.9
walker2d-mixed19.2-0.3/0.926.739.0±4.642.7±8.39.7 ± 5.3
hopper-mixed33.70.6/0.648.672.7±18.992.5±6.312.4 ± 5.8
", + "type": "table", + "image_path": "47dc016865358263b6ae66c8ae08e95fd81d867921262b7ad312a7ddce3dc217.jpg" + } + ] + } + ], + "index": 33, + "virtual_lines": [ + { + "bbox": [ + 106, + 483, + 510, + 540.0 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 106, + 540.0, + 510, + 597.0 + ], + "spans": [], + "index": 33 + }, + { + "bbox": [ + 106, + 597.0, + 510, + 654.0 + ], + "spans": [], + "index": 34 + } + ] + } + ], + "index": 31.0 + }, + { + "type": "text", + "bbox": [ + 108, + 677, + 505, + 711 + ], + "lines": [ + { + "bbox": [ + 106, + 678, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 678, + 505, + 690 + ], + "score": 1.0, + "content": "Performance on multi-modal datasets We first compare the performance on multi-modal", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 689, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 505, + 701 + ], + "score": 1.0, + "content": "datasets i.e. med-exp and mixed datasets. Results shown in Table 1 suggest that our method outper-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 712 + ], + "score": 1.0, + "content": "forms various model-free baselines on most of the multi-modal datasets, especially on hopper-mix", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 198, + 505, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 222, + 211 + ], + "score": 1.0, + "content": "and walker2d-mix by up to", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 222, + 199, + 241, + 209 + ], + "score": 0.69, + "content": "1 . 5 \\mathrm { x }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 241, + 198, + 505, + 211 + ], + "score": 1.0, + "content": ". Compared with BEAR (Kumar et al., 2019), our performance", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 210, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 505, + 222 + ], + "score": 1.0, + "content": "improvement arises from the advantage of the KL divergence over the kernel MMD (see discussions", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 221, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 289, + 234 + ], + "score": 1.0, + "content": "in Appendix B). The choice of parameters in", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 290, + 221, + 327, + 233 + ], + "score": 0.56, + "content": "\\operatorname { C Q L } ( \\mathcal { H } )", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 327, + 221, + 505, + 234 + ], + "score": 1.0, + "content": "makes it too conservative to achieve higher", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 232, + 162, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 162, + 244 + ], + "score": 1.0, + "content": "performance.", + "type": "text", + "cross_page": true + } + ], + "index": 9 + } + ], + "index": 36, + "bbox_fs": [ + 106, + 678, + 505, + 712 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 116, + 114, + 492, + 181 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 107, + 80, + 505, + 114 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 79, + 505, + 92 + ], + "spans": [ + { + "bbox": [ + 105, + 79, + 505, + 92 + ], + "score": 1.0, + "content": "Table 2: Results for Adroit tasks with human demonstrations in the D4RL (Fu et al., 2020) datasets.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 90, + 504, + 104 + ], + "spans": [ + { + "bbox": [ + 106, + 90, + 504, + 104 + ], + "score": 1.0, + "content": "The numbers are reported by following the same procedure as in Table 1 except we run the policy", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 102, + 499, + 115 + ], + "spans": [ + { + "bbox": [ + 106, + 102, + 499, + 115 + ], + "score": 1.0, + "content": "obtained at the last epoch of training for 1000 episodes due to large variance across different runs.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "table_body", + "bbox": [ + 116, + 114, + 492, + 181 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 116, + 114, + 492, + 181 + ], + "spans": [ + { + "bbox": [ + 116, + 114, + 492, + 181 + ], + "score": 0.972, + "html": "
Task NameBCBEARBRAC-p/vCQL(H)CQL(p)BRAC+ (Ours)
pen-human34.4-1.08.1/0.637.555.864.9± 1.6
hammer-human1.50.30.3/0.24.42.13.9 ± 0.9
door-human0.5-0.3-0.3/-0.39.99.111.5± 1.2
relocate-human0.0-0.3-0.3/-0.30.200.350.20 ± 0.11
", + "type": "table", + "image_path": "d35b761abb00052725fb7dbb57d4db067251f0cacfb7c1a4a06789a7e9fbb78d.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 116, + 114, + 492, + 136.33333333333334 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 116, + 136.33333333333334, + 492, + 158.66666666666669 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 116, + 158.66666666666669, + 492, + 181.00000000000003 + ], + "spans": [], + "index": 5 + } + ] + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 198, + 505, + 243 + ], + "lines": [ + { + "bbox": [ + 105, + 198, + 505, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 222, + 211 + ], + "score": 1.0, + "content": "and walker2d-mix by up to", + "type": "text" + }, + { + "bbox": [ + 222, + 199, + 241, + 209 + ], + "score": 0.69, + "content": "1 . 5 \\mathrm { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 198, + 505, + 211 + ], + "score": 1.0, + "content": ". Compared with BEAR (Kumar et al., 2019), our performance", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 210, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 505, + 222 + ], + "score": 1.0, + "content": "improvement arises from the advantage of the KL divergence over the kernel MMD (see discussions", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 221, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 289, + 234 + ], + "score": 1.0, + "content": "in Appendix B). The choice of parameters in", + "type": "text" + }, + { + "bbox": [ + 290, + 221, + 327, + 233 + ], + "score": 0.56, + "content": "\\operatorname { C Q L } ( \\mathcal { H } )", + "type": "inline_equation" + }, + { + "bbox": [ + 327, + 221, + 505, + 234 + ], + "score": 1.0, + "content": "makes it too conservative to achieve higher", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 232, + 162, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 162, + 244 + ], + "score": 1.0, + "content": "performance.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 106, + 255, + 505, + 310 + ], + "lines": [ + { + "bbox": [ + 106, + 255, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 106, + 255, + 505, + 267 + ], + "score": 1.0, + "content": "Performance on single-modal datasets The performance of our method on single-modal (rand", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 265, + 505, + 279 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 505, + 279 + ], + "score": 1.0, + "content": "and med) dataset outperforms or matches with baseline methods as evident from Table 1 except", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 276, + 506, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 506, + 290 + ], + "score": 1.0, + "content": "halfcheetah-random dataset. We observe that the performance is very sensitive to the choice of", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 287, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 505, + 300 + ], + "score": 1.0, + "content": "target policy entropy. We hypothesize that the our choice of target policy entropy in the halfcheetah-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 299, + 504, + 311 + ], + "spans": [ + { + "bbox": [ + 106, + 299, + 504, + 311 + ], + "score": 1.0, + "content": "random task makes it hard to compose correct sub-optimal policies from a random collected dataset.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12 + }, + { + "type": "image", + "bbox": [ + 108, + 320, + 502, + 438 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 320, + 502, + 438 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 320, + 502, + 438 + ], + "spans": [ + { + "bbox": [ + 108, + 320, + 502, + 438 + ], + "score": 0.969, + "type": "image", + "image_path": "c3e749d5069b0b1565520c3bc0b5e5d26cad7d2efabb6fab7f4282bf39bc0a5c.jpg" + } + ] + } + ], + "index": 16, + "virtual_lines": [ + { + "bbox": [ + 108, + 320, + 502, + 359.3333333333333 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 108, + 359.3333333333333, + 502, + 398.66666666666663 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 108, + 398.66666666666663, + 502, + 437.99999999999994 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 448, + 503, + 471 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 448, + 504, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 396, + 459 + ], + "score": 1.0, + "content": "Figure 1: Left: learning curve of pen-human-v0 task. Right: the average", + "type": "text" + }, + { + "bbox": [ + 397, + 448, + 406, + 459 + ], + "score": 0.31, + "content": "\\mathrm { Q }", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 448, + 504, + 459 + ], + "score": 1.0, + "content": "value of the first ensem-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 459, + 408, + 472 + ], + "spans": [ + { + "bbox": [ + 106, + 459, + 408, + 472 + ], + "score": 1.0, + "content": "ble over the course of training. Both curves are smoothed by a factor of 20.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18.5 + } + ], + "index": 17.25 + }, + { + "type": "text", + "bbox": [ + 107, + 488, + 505, + 609 + ], + "lines": [ + { + "bbox": [ + 105, + 487, + 506, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 506, + 500 + ], + "score": 1.0, + "content": "Performance on datasets with human demonstrations The performance on Adroit tasks is", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 498, + 505, + 511 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 505, + 511 + ], + "score": 1.0, + "content": "shown in Table 2. These tasks are substantially harder than OpenAI gym tasks due to limited training", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 509, + 505, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 505, + 522 + ], + "score": 1.0, + "content": "data in a high dimensional observation and action space. Our method makes non-trivial improve-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 520, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 520, + 505, + 533 + ], + "score": 1.0, + "content": "ment over the behavior cloning. Compared with the state-of-the-art approaches, our approach is", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 531, + 504, + 544 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 504, + 544 + ], + "score": 1.0, + "content": "superior on half of the tasks and matches the asymptotic performance on the remaining ones. Fig-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 542, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 505, + 555 + ], + "score": 1.0, + "content": "ure 1 shows that the Q value is bounded when the gradient penalized policy evaluation technique is", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 553, + 505, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 553, + 505, + 566 + ], + "score": 1.0, + "content": "employed. On the contrary, the Q value without the gradient penalized policy evaluation increases", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 564, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 106, + 564, + 505, + 576 + ], + "score": 1.0, + "content": "exponentially. Note that we use MMD with Laplacian kernel for Adroit tasks. We observe that the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 576, + 505, + 587 + ], + "spans": [ + { + "bbox": [ + 106, + 576, + 505, + 587 + ], + "score": 1.0, + "content": "KL-based regularization struggles with datasets collected with narrow behavior distributions (have", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 587, + 504, + 598 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 504, + 598 + ], + "score": 1.0, + "content": "large density within a tiny space and almost zero density anywhere else). In such a case, the KL", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 596, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 505, + 611 + ], + "score": 1.0, + "content": "divergence is sensitive to tiny policy changes, making gradient-based optimization hard to converge.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 25 + }, + { + "type": "title", + "bbox": [ + 108, + 633, + 209, + 644 + ], + "lines": [ + { + "bbox": [ + 105, + 632, + 210, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 210, + 646 + ], + "score": 1.0, + "content": "5.2 ABLATION STUDY", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 653, + 505, + 687 + ], + "lines": [ + { + "bbox": [ + 105, + 653, + 505, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 424, + 666 + ], + "score": 1.0, + "content": "To answer question (2), (3) and (4), we conduct a thorough ablation study on", + "type": "text" + }, + { + "bbox": [ + 425, + 654, + 459, + 664 + ], + "score": 0.51, + "content": "{ \\mathrm { B R A C } } +", + "type": "inline_equation" + }, + { + "bbox": [ + 460, + 653, + 505, + 666 + ], + "score": 1.0, + "content": "on various", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 663, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 505, + 677 + ], + "score": 1.0, + "content": "tasks with different data collection policies (hopper-mixed, walker2d-medium-expert, halfcheetah-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 675, + 148, + 688 + ], + "spans": [ + { + "bbox": [ + 105, + 675, + 148, + 688 + ], + "score": 1.0, + "content": "medium).", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "Sampled-based MMD vs. analytical upper bound KL The results of using sampled-based", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "score": 1.0, + "content": "MMD versus analytical upper bound KL are shown in Figure 2a. The difference of the perfor-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "score": 1.0, + "content": "mance in the single-modal dataset (halfcheetah-medium) is negligible. However, the performance", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 303, + 751, + 309, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 116, + 114, + 492, + 181 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 107, + 80, + 505, + 114 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 79, + 505, + 92 + ], + "spans": [ + { + "bbox": [ + 105, + 79, + 505, + 92 + ], + "score": 1.0, + "content": "Table 2: Results for Adroit tasks with human demonstrations in the D4RL (Fu et al., 2020) datasets.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 90, + 504, + 104 + ], + "spans": [ + { + "bbox": [ + 106, + 90, + 504, + 104 + ], + "score": 1.0, + "content": "The numbers are reported by following the same procedure as in Table 1 except we run the policy", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 102, + 499, + 115 + ], + "spans": [ + { + "bbox": [ + 106, + 102, + 499, + 115 + ], + "score": 1.0, + "content": "obtained at the last epoch of training for 1000 episodes due to large variance across different runs.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "table_body", + "bbox": [ + 116, + 114, + 492, + 181 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 116, + 114, + 492, + 181 + ], + "spans": [ + { + "bbox": [ + 116, + 114, + 492, + 181 + ], + "score": 0.972, + "html": "
Task NameBCBEARBRAC-p/vCQL(H)CQL(p)BRAC+ (Ours)
pen-human34.4-1.08.1/0.637.555.864.9± 1.6
hammer-human1.50.30.3/0.24.42.13.9 ± 0.9
door-human0.5-0.3-0.3/-0.39.99.111.5± 1.2
relocate-human0.0-0.3-0.3/-0.30.200.350.20 ± 0.11
", + "type": "table", + "image_path": "d35b761abb00052725fb7dbb57d4db067251f0cacfb7c1a4a06789a7e9fbb78d.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 116, + 114, + 492, + 136.33333333333334 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 116, + 136.33333333333334, + 492, + 158.66666666666669 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 116, + 158.66666666666669, + 492, + 181.00000000000003 + ], + "spans": [], + "index": 5 + } + ] + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 198, + 505, + 243 + ], + "lines": [], + "index": 7.5, + "bbox_fs": [ + 105, + 198, + 505, + 244 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 255, + 505, + 310 + ], + "lines": [ + { + "bbox": [ + 106, + 255, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 106, + 255, + 505, + 267 + ], + "score": 1.0, + "content": "Performance on single-modal datasets The performance of our method on single-modal (rand", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 265, + 505, + 279 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 505, + 279 + ], + "score": 1.0, + "content": "and med) dataset outperforms or matches with baseline methods as evident from Table 1 except", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 276, + 506, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 506, + 290 + ], + "score": 1.0, + "content": "halfcheetah-random dataset. We observe that the performance is very sensitive to the choice of", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 287, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 505, + 300 + ], + "score": 1.0, + "content": "target policy entropy. We hypothesize that the our choice of target policy entropy in the halfcheetah-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 299, + 504, + 311 + ], + "spans": [ + { + "bbox": [ + 106, + 299, + 504, + 311 + ], + "score": 1.0, + "content": "random task makes it hard to compose correct sub-optimal policies from a random collected dataset.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 255, + 506, + 311 + ] + }, + { + "type": "image", + "bbox": [ + 108, + 320, + 502, + 438 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 320, + 502, + 438 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 320, + 502, + 438 + ], + "spans": [ + { + "bbox": [ + 108, + 320, + 502, + 438 + ], + "score": 0.969, + "type": "image", + "image_path": "c3e749d5069b0b1565520c3bc0b5e5d26cad7d2efabb6fab7f4282bf39bc0a5c.jpg" + } + ] + } + ], + "index": 16, + "virtual_lines": [ + { + "bbox": [ + 108, + 320, + 502, + 359.3333333333333 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 108, + 359.3333333333333, + 502, + 398.66666666666663 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 108, + 398.66666666666663, + 502, + 437.99999999999994 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 448, + 503, + 471 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 448, + 504, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 396, + 459 + ], + "score": 1.0, + "content": "Figure 1: Left: learning curve of pen-human-v0 task. Right: the average", + "type": "text" + }, + { + "bbox": [ + 397, + 448, + 406, + 459 + ], + "score": 0.31, + "content": "\\mathrm { Q }", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 448, + 504, + 459 + ], + "score": 1.0, + "content": "value of the first ensem-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 459, + 408, + 472 + ], + "spans": [ + { + "bbox": [ + 106, + 459, + 408, + 472 + ], + "score": 1.0, + "content": "ble over the course of training. Both curves are smoothed by a factor of 20.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18.5 + } + ], + "index": 17.25 + }, + { + "type": "text", + "bbox": [ + 107, + 488, + 505, + 609 + ], + "lines": [ + { + "bbox": [ + 105, + 487, + 506, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 506, + 500 + ], + "score": 1.0, + "content": "Performance on datasets with human demonstrations The performance on Adroit tasks is", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 498, + 505, + 511 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 505, + 511 + ], + "score": 1.0, + "content": "shown in Table 2. These tasks are substantially harder than OpenAI gym tasks due to limited training", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 509, + 505, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 505, + 522 + ], + "score": 1.0, + "content": "data in a high dimensional observation and action space. Our method makes non-trivial improve-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 520, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 520, + 505, + 533 + ], + "score": 1.0, + "content": "ment over the behavior cloning. Compared with the state-of-the-art approaches, our approach is", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 531, + 504, + 544 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 504, + 544 + ], + "score": 1.0, + "content": "superior on half of the tasks and matches the asymptotic performance on the remaining ones. Fig-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 542, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 505, + 555 + ], + "score": 1.0, + "content": "ure 1 shows that the Q value is bounded when the gradient penalized policy evaluation technique is", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 553, + 505, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 553, + 505, + 566 + ], + "score": 1.0, + "content": "employed. On the contrary, the Q value without the gradient penalized policy evaluation increases", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 564, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 106, + 564, + 505, + 576 + ], + "score": 1.0, + "content": "exponentially. Note that we use MMD with Laplacian kernel for Adroit tasks. We observe that the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 576, + 505, + 587 + ], + "spans": [ + { + "bbox": [ + 106, + 576, + 505, + 587 + ], + "score": 1.0, + "content": "KL-based regularization struggles with datasets collected with narrow behavior distributions (have", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 587, + 504, + 598 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 504, + 598 + ], + "score": 1.0, + "content": "large density within a tiny space and almost zero density anywhere else). In such a case, the KL", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 596, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 505, + 611 + ], + "score": 1.0, + "content": "divergence is sensitive to tiny policy changes, making gradient-based optimization hard to converge.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 487, + 506, + 611 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 633, + 209, + 644 + ], + "lines": [ + { + "bbox": [ + 105, + 632, + 210, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 210, + 646 + ], + "score": 1.0, + "content": "5.2 ABLATION STUDY", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 653, + 505, + 687 + ], + "lines": [ + { + "bbox": [ + 105, + 653, + 505, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 424, + 666 + ], + "score": 1.0, + "content": "To answer question (2), (3) and (4), we conduct a thorough ablation study on", + "type": "text" + }, + { + "bbox": [ + 425, + 654, + 459, + 664 + ], + "score": 0.51, + "content": "{ \\mathrm { B R A C } } +", + "type": "inline_equation" + }, + { + "bbox": [ + 460, + 653, + 505, + 666 + ], + "score": 1.0, + "content": "on various", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 663, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 505, + 677 + ], + "score": 1.0, + "content": "tasks with different data collection policies (hopper-mixed, walker2d-medium-expert, halfcheetah-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 675, + 148, + 688 + ], + "spans": [ + { + "bbox": [ + 105, + 675, + 148, + 688 + ], + "score": 1.0, + "content": "medium).", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33, + "bbox_fs": [ + 105, + 653, + 505, + 688 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "Sampled-based MMD vs. analytical upper bound KL The results of using sampled-based", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "score": 1.0, + "content": "MMD versus analytical upper bound KL are shown in Figure 2a. The difference of the perfor-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "score": 1.0, + "content": "mance in the single-modal dataset (halfcheetah-medium) is negligible. However, the performance", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 576, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 505, + 588 + ], + "score": 1.0, + "content": "on multi-modal datasets is varied. Our toy example in Appendix B suggests that MMD and the", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 587, + 505, + 598 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 505, + 598 + ], + "score": 1.0, + "content": "backward KL divergence tends to cover all the “modes” in the behavior policy while the forward", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 597, + 505, + 610 + ], + "spans": [ + { + "bbox": [ + 106, + 597, + 505, + 610 + ], + "score": 1.0, + "content": "KL divergence tends to seek one of the “mode” in the behavior policy. Note that this argument is only", + "type": "text", + "cross_page": true + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 608, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 608, + 505, + 621 + ], + "score": 1.0, + "content": "valid if the learned policy is single-modal (e.g. Gaussian distribution). The superior performance", + "type": "text", + "cross_page": true + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 619, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 505, + 632 + ], + "score": 1.0, + "content": "in the walker2d-medium-expert when using forward KL regularization supports this argument. The", + "type": "text", + "cross_page": true + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 631, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 631, + 505, + 642 + ], + "score": 1.0, + "content": "results in hopper-mixed task seems to be contradictory. We hypothesize that since the analytical KL", + "type": "text", + "cross_page": true + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 642, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 642, + 505, + 654 + ], + "score": 1.0, + "content": "has low variance, the policy quickly adopts the out-of-distribution actions when available while in", + "type": "text", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 653, + 501, + 665 + ], + "spans": [ + { + "bbox": [ + 106, + 653, + 501, + 665 + ], + "score": 1.0, + "content": "sample-based methods, such adoption is slower due to higher variance in the policy regularization.", + "type": "text", + "cross_page": true + } + ], + "index": 16 + } + ], + "index": 36, + "bbox_fs": [ + 105, + 698, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 66, + 504, + 482 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 66, + 504, + 482 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 66, + 504, + 482 + ], + "spans": [ + { + "bbox": [ + 106, + 66, + 504, + 482 + ], + "score": 0.971, + "type": "image", + "image_path": "936da787ddd671fa414383deb9d728d42c0ce8d083411c0c19e2e2ca738bcbe8.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 66, + 504, + 204.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 204.66666666666666, + 504, + 343.3333333333333 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 343.3333333333333, + 504, + 482.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 140, + 479, + 469, + 491 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 140, + 478, + 470, + 492 + ], + "spans": [ + { + "bbox": [ + 140, + 478, + 470, + 492 + ], + "score": 1.0, + "content": "(c) Gradient penalty vs. No gradient penalty. State-wise Lagrange multiplier. Forward KL.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "image_caption", + "bbox": [ + 106, + 499, + 505, + 555 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 500, + 505, + 511 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 505, + 511 + ], + "score": 1.0, + "content": "Figure 2: Figures of ablation study. Each setting is repeated for 4 random seeds. The curve is the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 510, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 505, + 523 + ], + "score": 1.0, + "content": "mean and the shaded area is the standard deviation. The curves are smoothed by a factor of 20. The", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 522, + 504, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 522, + 504, + 534 + ], + "score": 1.0, + "content": "number of gradient steps per epoch is 2000. To make fair comparison, we only substitute KL diver-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 531, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 505, + 545 + ], + "score": 1.0, + "content": "gence with MMD-based measurement with additional MMD-specific hyperparameter tuning. The", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 107, + 544, + 498, + 556 + ], + "spans": [ + { + "bbox": [ + 107, + 544, + 498, + 556 + ], + "score": 1.0, + "content": "other design choices are different from (Kumar et al., 2019). Details can be found in Appendix D.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 107, + 576, + 505, + 664 + ], + "lines": [ + { + "bbox": [ + 105, + 576, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 505, + 588 + ], + "score": 1.0, + "content": "on multi-modal datasets is varied. Our toy example in Appendix B suggests that MMD and the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 587, + 505, + 598 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 505, + 598 + ], + "score": 1.0, + "content": "backward KL divergence tends to cover all the “modes” in the behavior policy while the forward", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 597, + 505, + 610 + ], + "spans": [ + { + "bbox": [ + 106, + 597, + 505, + 610 + ], + "score": 1.0, + "content": "KL divergence tends to seek one of the “mode” in the behavior policy. Note that this argument is only", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 608, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 608, + 505, + 621 + ], + "score": 1.0, + "content": "valid if the learned policy is single-modal (e.g. Gaussian distribution). The superior performance", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 619, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 505, + 632 + ], + "score": 1.0, + "content": "in the walker2d-medium-expert when using forward KL regularization supports this argument. The", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 631, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 631, + 505, + 642 + ], + "score": 1.0, + "content": "results in hopper-mixed task seems to be contradictory. We hypothesize that since the analytical KL", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 642, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 642, + 505, + 654 + ], + "score": 1.0, + "content": "has low variance, the policy quickly adopts the out-of-distribution actions when available while in", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 653, + 501, + 665 + ], + "spans": [ + { + "bbox": [ + 106, + 653, + 501, + 665 + ], + "score": 1.0, + "content": "sample-based methods, such adoption is slower due to higher variance in the policy regularization.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 107, + 677, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 676, + 505, + 689 + ], + "score": 1.0, + "content": "State-wise vs. global regularization The performance of using global and state-wise regulariza-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 686, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 686, + 505, + 700 + ], + "score": 1.0, + "content": "tion on various tasks is shown in Figure 2b. It is noticeable that the state-wise regularization im-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "proves the performance in hopper-mixed and walker2d-medium-expert task, while the performance", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "score": 1.0, + "content": "in halfcheetah-medium does not show much improvement. To understand the consequence of the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "score": 1.0, + "content": "state-wise regularization, we plot the histogram of the KL divergence of all the states in the dataset", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 306, + 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 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 761 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 761 + ], + "score": 1.0, + "content": "8", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 66, + 504, + 482 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 66, + 504, + 482 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 66, + 504, + 482 + ], + "spans": [ + { + "bbox": [ + 106, + 66, + 504, + 482 + ], + "score": 0.971, + "type": "image", + "image_path": "936da787ddd671fa414383deb9d728d42c0ce8d083411c0c19e2e2ca738bcbe8.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 66, + 504, + 204.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 204.66666666666666, + 504, + 343.3333333333333 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 343.3333333333333, + 504, + 482.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 140, + 479, + 469, + 491 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 140, + 478, + 470, + 492 + ], + "spans": [ + { + "bbox": [ + 140, + 478, + 470, + 492 + ], + "score": 1.0, + "content": "(c) Gradient penalty vs. No gradient penalty. State-wise Lagrange multiplier. Forward KL.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "image_caption", + "bbox": [ + 106, + 499, + 505, + 555 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 500, + 505, + 511 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 505, + 511 + ], + "score": 1.0, + "content": "Figure 2: Figures of ablation study. Each setting is repeated for 4 random seeds. The curve is the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 510, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 505, + 523 + ], + "score": 1.0, + "content": "mean and the shaded area is the standard deviation. The curves are smoothed by a factor of 20. The", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 522, + 504, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 522, + 504, + 534 + ], + "score": 1.0, + "content": "number of gradient steps per epoch is 2000. To make fair comparison, we only substitute KL diver-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 531, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 505, + 545 + ], + "score": 1.0, + "content": "gence with MMD-based measurement with additional MMD-specific hyperparameter tuning. The", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 107, + 544, + 498, + 556 + ], + "spans": [ + { + "bbox": [ + 107, + 544, + 498, + 556 + ], + "score": 1.0, + "content": "other design choices are different from (Kumar et al., 2019). Details can be found in Appendix D.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 107, + 576, + 505, + 664 + ], + "lines": [], + "index": 12.5, + "bbox_fs": [ + 105, + 576, + 505, + 665 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 677, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 676, + 505, + 689 + ], + "score": 1.0, + "content": "State-wise vs. global regularization The performance of using global and state-wise regulariza-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 686, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 686, + 505, + 700 + ], + "score": 1.0, + "content": "tion on various tasks is shown in Figure 2b. It is noticeable that the state-wise regularization im-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "proves the performance in hopper-mixed and walker2d-medium-expert task, while the performance", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "score": 1.0, + "content": "in halfcheetah-medium does not show much improvement. To understand the consequence of the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "score": 1.0, + "content": "state-wise regularization, we plot the histogram of the KL divergence of all the states in the dataset", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 254, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 505, + 266 + ], + "score": 1.0, + "content": "in Figure 3. The KL divergence histogram of using state-wise regularization is more concentrated", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 264, + 505, + 278 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 505, + 278 + ], + "score": 1.0, + "content": "around the threshold while the global regularization is more sporadic. Strictly enforcing the policy", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 275, + 507, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 507, + 289 + ], + "score": 1.0, + "content": "regularization around the threshold helps avoid out-of-distribution actions, that is often caused by a", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 287, + 205, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 205, + 298 + ], + "score": 1.0, + "content": "few states in the dataset.", + "type": "text", + "cross_page": true + } + ], + "index": 8 + } + ], + "index": 19, + "bbox_fs": [ + 105, + 676, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 108, + 79, + 504, + 200 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 79, + 504, + 200 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 79, + 504, + 200 + ], + "spans": [ + { + "bbox": [ + 108, + 79, + 504, + 200 + ], + "score": 0.956, + "type": "image", + "image_path": "3992389a7bba94f23ff3c5baa970981f092f58a99c2dab5472bed071a685fb24.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 108, + 79, + 504, + 119.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 108, + 119.33333333333334, + 504, + 159.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 108, + 159.66666666666669, + 504, + 200.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 209, + 504, + 233 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 209, + 506, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 506, + 223 + ], + "score": 1.0, + "content": "Figure 3: Histogram of the KL divergence of all the states in the dataset with global and state-wise", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 220, + 190, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 190, + 234 + ], + "score": 1.0, + "content": "Lagrange multiplier.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 107, + 254, + 505, + 298 + ], + "lines": [ + { + "bbox": [ + 105, + 254, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 505, + 266 + ], + "score": 1.0, + "content": "in Figure 3. The KL divergence histogram of using state-wise regularization is more concentrated", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 264, + 505, + 278 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 505, + 278 + ], + "score": 1.0, + "content": "around the threshold while the global regularization is more sporadic. Strictly enforcing the policy", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 275, + 507, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 507, + 289 + ], + "score": 1.0, + "content": "regularization around the threshold helps avoid out-of-distribution actions, that is often caused by a", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 287, + 205, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 205, + 298 + ], + "score": 1.0, + "content": "few states in the dataset.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 107, + 311, + 505, + 399 + ], + "lines": [ + { + "bbox": [ + 106, + 310, + 506, + 323 + ], + "spans": [ + { + "bbox": [ + 106, + 310, + 506, + 323 + ], + "score": 1.0, + "content": "Gradient penalty vs. no gradient penalty Even with policy regularization, evaluating the Q", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 321, + 505, + 334 + ], + "spans": [ + { + "bbox": [ + 106, + 321, + 505, + 334 + ], + "score": 1.0, + "content": "value at the out-of-distribution actions can’t be fully avoided. Thus, it is important to bound the Q", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 332, + 505, + 344 + ], + "spans": [ + { + "bbox": [ + 106, + 332, + 505, + 344 + ], + "score": 1.0, + "content": "value at the out-of-distribution actions such that their values are not greater than the Q value of in-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 343, + 505, + 356 + ], + "spans": [ + { + "bbox": [ + 106, + 343, + 505, + 356 + ], + "score": 1.0, + "content": "distribution actions. Figure 2c shows the performance with and without gradient penalty in the policy", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 354, + 505, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 354, + 505, + 367 + ], + "score": 1.0, + "content": "evaluation step. While there is little difference in the hopper-mixed and the halfcheetah-medium", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 365, + 505, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 365, + 505, + 377 + ], + "score": 1.0, + "content": "task, the performance in the walker2d-medium-expert task stabilizes with the gradient penalized", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 376, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 505, + 389 + ], + "score": 1.0, + "content": "policy evaluation. On the contrary, the performance deteriorates over time without gradient penalty.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 387, + 291, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 387, + 291, + 399 + ], + "score": 1.0, + "content": "Please refer to Appendix D for more analysis.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 12.5 + }, + { + "type": "title", + "bbox": [ + 108, + 415, + 292, + 427 + ], + "lines": [ + { + "bbox": [ + 105, + 414, + 294, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 294, + 428 + ], + "score": 1.0, + "content": "6 DISCUSSIONS AND LIMITATIONS", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 439, + 504, + 495 + ], + "lines": [ + { + "bbox": [ + 107, + 439, + 505, + 451 + ], + "spans": [ + { + "bbox": [ + 107, + 439, + 505, + 451 + ], + "score": 1.0, + "content": "There are several limitations of our approach. The discussion in Appendix D suggests that although", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 449, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 106, + 449, + 505, + 464 + ], + "score": 1.0, + "content": "KL-regularized offline policy optimization is good at combining sub-optimal policies, they may", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 462, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 106, + 462, + 505, + 474 + ], + "score": 1.0, + "content": "stuck at local optimums; and they are hard to escape. Another drawback is that the threshold value", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 473, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 505, + 484 + ], + "score": 1.0, + "content": "is hard to set. In our experiments, we try a few numbers that are above the minimum possible KL", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 482, + 444, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 444, + 497 + ], + "score": 1.0, + "content": "threshold, which is obtained by training a policy that minimizes that KL divergence.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 501, + 505, + 600 + ], + "lines": [ + { + "bbox": [ + 105, + 500, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 505, + 513 + ], + "score": 1.0, + "content": "Finally, we conjecture that the behavior-regularized approach is not sufficient to tackle offline RL", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "score": 1.0, + "content": "problems since it fully ignores the state distribution. To see this, we can create a dataset that only", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 523, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 505, + 535 + ], + "score": 1.0, + "content": "adds a few trajectories from an expert policy to a dataset collected by a low-quality policy. If the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "score": 1.0, + "content": "low-quality policy doesn’t visit the “good” states in the expert policy (can’t combine sub-optimal", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 543, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 505, + 556 + ], + "score": 1.0, + "content": "policies), behavior-regularized approach leads to a policy that imitates the expert policy. Such imita-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 555, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 106, + 555, + 505, + 568 + ], + "score": 1.0, + "content": "tion is likely to fail due to compounding errors (Ross et al., 2010). The right approach for this dataset", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 567, + 504, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 504, + 578 + ], + "score": 1.0, + "content": "is to completely ignore expert trajectories and combine sub-optimal policies in the low-quality re-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 576, + 506, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 506, + 590 + ], + "score": 1.0, + "content": "gions. To achieve this, we need to consider the state distribution as the density of the “good” states", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 588, + 156, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 156, + 601 + ], + "score": 1.0, + "content": "is very low.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 27 + }, + { + "type": "title", + "bbox": [ + 108, + 615, + 195, + 628 + ], + "lines": [ + { + "bbox": [ + 104, + 613, + 197, + 632 + ], + "spans": [ + { + "bbox": [ + 104, + 613, + 197, + 632 + ], + "score": 1.0, + "content": "7 CONCLUSION", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 641, + 505, + 707 + ], + "lines": [ + { + "bbox": [ + 104, + 639, + 505, + 655 + ], + "spans": [ + { + "bbox": [ + 104, + 639, + 505, + 655 + ], + "score": 1.0, + "content": "In this paper, we improved the behavior regularized offline reinforcement learning by proposing", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 652, + 505, + 665 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 505, + 665 + ], + "score": 1.0, + "content": "a low-variance upper bound of the KL divergence estimator to reduce variance, state-dependent", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 662, + 506, + 677 + ], + "spans": [ + { + "bbox": [ + 104, + 662, + 506, + 677 + ], + "score": 1.0, + "content": "Lagrange multiplier to allow more freedom of deviation to high probability states while restricting", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 674, + 505, + 686 + ], + "spans": [ + { + "bbox": [ + 106, + 674, + 505, + 686 + ], + "score": 1.0, + "content": "low probability states and gradient penalized policy evaluation such that the Q values of out-of-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 684, + 505, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 684, + 505, + 698 + ], + "score": 1.0, + "content": "distribution actions are not greater than those of in-distribution actions. Our experimental results on", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 696, + 379, + 707 + ], + "spans": [ + { + "bbox": [ + 106, + 696, + 379, + 707 + ], + "score": 1.0, + "content": "challenging benchmarks illustrate the benefits of our improvements.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 35.5 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 306, + 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 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 108, + 79, + 504, + 200 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 79, + 504, + 200 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 79, + 504, + 200 + ], + "spans": [ + { + "bbox": [ + 108, + 79, + 504, + 200 + ], + "score": 0.956, + "type": "image", + "image_path": "3992389a7bba94f23ff3c5baa970981f092f58a99c2dab5472bed071a685fb24.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 108, + 79, + 504, + 119.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 108, + 119.33333333333334, + 504, + 159.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 108, + 159.66666666666669, + 504, + 200.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 209, + 504, + 233 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 209, + 506, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 506, + 223 + ], + "score": 1.0, + "content": "Figure 3: Histogram of the KL divergence of all the states in the dataset with global and state-wise", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 220, + 190, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 190, + 234 + ], + "score": 1.0, + "content": "Lagrange multiplier.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 107, + 254, + 505, + 298 + ], + "lines": [], + "index": 6.5, + "bbox_fs": [ + 105, + 254, + 507, + 298 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 311, + 505, + 399 + ], + "lines": [ + { + "bbox": [ + 106, + 310, + 506, + 323 + ], + "spans": [ + { + "bbox": [ + 106, + 310, + 506, + 323 + ], + "score": 1.0, + "content": "Gradient penalty vs. no gradient penalty Even with policy regularization, evaluating the Q", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 321, + 505, + 334 + ], + "spans": [ + { + "bbox": [ + 106, + 321, + 505, + 334 + ], + "score": 1.0, + "content": "value at the out-of-distribution actions can’t be fully avoided. Thus, it is important to bound the Q", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 332, + 505, + 344 + ], + "spans": [ + { + "bbox": [ + 106, + 332, + 505, + 344 + ], + "score": 1.0, + "content": "value at the out-of-distribution actions such that their values are not greater than the Q value of in-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 343, + 505, + 356 + ], + "spans": [ + { + "bbox": [ + 106, + 343, + 505, + 356 + ], + "score": 1.0, + "content": "distribution actions. Figure 2c shows the performance with and without gradient penalty in the policy", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 354, + 505, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 354, + 505, + 367 + ], + "score": 1.0, + "content": "evaluation step. While there is little difference in the hopper-mixed and the halfcheetah-medium", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 365, + 505, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 365, + 505, + 377 + ], + "score": 1.0, + "content": "task, the performance in the walker2d-medium-expert task stabilizes with the gradient penalized", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 376, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 505, + 389 + ], + "score": 1.0, + "content": "policy evaluation. On the contrary, the performance deteriorates over time without gradient penalty.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 387, + 291, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 387, + 291, + 399 + ], + "score": 1.0, + "content": "Please refer to Appendix D for more analysis.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 12.5, + "bbox_fs": [ + 105, + 310, + 506, + 399 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 415, + 292, + 427 + ], + "lines": [ + { + "bbox": [ + 105, + 414, + 294, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 294, + 428 + ], + "score": 1.0, + "content": "6 DISCUSSIONS AND LIMITATIONS", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 439, + 504, + 495 + ], + "lines": [ + { + "bbox": [ + 107, + 439, + 505, + 451 + ], + "spans": [ + { + "bbox": [ + 107, + 439, + 505, + 451 + ], + "score": 1.0, + "content": "There are several limitations of our approach. The discussion in Appendix D suggests that although", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 449, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 106, + 449, + 505, + 464 + ], + "score": 1.0, + "content": "KL-regularized offline policy optimization is good at combining sub-optimal policies, they may", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 462, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 106, + 462, + 505, + 474 + ], + "score": 1.0, + "content": "stuck at local optimums; and they are hard to escape. Another drawback is that the threshold value", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 473, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 505, + 484 + ], + "score": 1.0, + "content": "is hard to set. In our experiments, we try a few numbers that are above the minimum possible KL", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 482, + 444, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 444, + 497 + ], + "score": 1.0, + "content": "threshold, which is obtained by training a policy that minimizes that KL divergence.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20, + "bbox_fs": [ + 105, + 439, + 505, + 497 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 501, + 505, + 600 + ], + "lines": [ + { + "bbox": [ + 105, + 500, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 505, + 513 + ], + "score": 1.0, + "content": "Finally, we conjecture that the behavior-regularized approach is not sufficient to tackle offline RL", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "score": 1.0, + "content": "problems since it fully ignores the state distribution. To see this, we can create a dataset that only", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 523, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 505, + 535 + ], + "score": 1.0, + "content": "adds a few trajectories from an expert policy to a dataset collected by a low-quality policy. If the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "score": 1.0, + "content": "low-quality policy doesn’t visit the “good” states in the expert policy (can’t combine sub-optimal", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 543, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 505, + 556 + ], + "score": 1.0, + "content": "policies), behavior-regularized approach leads to a policy that imitates the expert policy. Such imita-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 555, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 106, + 555, + 505, + 568 + ], + "score": 1.0, + "content": "tion is likely to fail due to compounding errors (Ross et al., 2010). The right approach for this dataset", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 567, + 504, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 504, + 578 + ], + "score": 1.0, + "content": "is to completely ignore expert trajectories and combine sub-optimal policies in the low-quality re-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 576, + 506, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 506, + 590 + ], + "score": 1.0, + "content": "gions. To achieve this, we need to consider the state distribution as the density of the “good” states", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 588, + 156, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 156, + 601 + ], + "score": 1.0, + "content": "is very low.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 500, + 506, + 601 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 615, + 195, + 628 + ], + "lines": [ + { + "bbox": [ + 104, + 613, + 197, + 632 + ], + "spans": [ + { + "bbox": [ + 104, + 613, + 197, + 632 + ], + "score": 1.0, + "content": "7 CONCLUSION", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 641, + 505, + 707 + ], + "lines": [ + { + "bbox": [ + 104, + 639, + 505, + 655 + ], + "spans": [ + { + "bbox": [ + 104, + 639, + 505, + 655 + ], + "score": 1.0, + "content": "In this paper, we improved the behavior regularized offline reinforcement learning by proposing", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 652, + 505, + 665 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 505, + 665 + ], + "score": 1.0, + "content": "a low-variance upper bound of the KL divergence estimator to reduce variance, state-dependent", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 662, + 506, + 677 + ], + "spans": [ + { + "bbox": [ + 104, + 662, + 506, + 677 + ], + "score": 1.0, + "content": "Lagrange multiplier to allow more freedom of deviation to high probability states while restricting", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 674, + 505, + 686 + ], + "spans": [ + { + "bbox": [ + 106, + 674, + 505, + 686 + ], + "score": 1.0, + "content": "low probability states and gradient penalized policy evaluation such that the Q values of out-of-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 684, + 505, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 684, + 505, + 698 + ], + "score": 1.0, + "content": "distribution actions are not greater than those of in-distribution actions. Our experimental results on", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 696, + 379, + 707 + ], + "spans": [ + { + "bbox": [ + 106, + 696, + 379, + 707 + ], + "score": 1.0, + "content": "challenging benchmarks illustrate the benefits of our improvements.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 35.5, + "bbox_fs": [ + 104, + 639, + 506, + 707 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 176, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 176, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 176, + 94 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 100, + 503, + 112 + ], + "lines": [ + { + "bbox": [ + 105, + 98, + 505, + 114 + ], + "spans": [ + { + "bbox": [ + 105, + 98, + 505, + 114 + ], + "score": 1.0, + "content": "Abien Fred Agarap. Deep learning using rectified linear units (relu). ArXiv, abs/1803.08375, 2018.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 106, + 119, + 504, + 142 + ], + "lines": [ + { + "bbox": [ + 106, + 119, + 505, + 132 + ], + "spans": [ + { + "bbox": [ + 106, + 119, + 505, + 132 + ], + "score": 1.0, + "content": "Arthur Argenson and Gabriel Dulac-Arnold. Model-based offline planning. ArXiv, abs/2008.05556,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 114, + 128, + 143, + 144 + ], + "spans": [ + { + "bbox": [ + 114, + 128, + 143, + 144 + ], + "score": 1.0, + "content": "2020.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 106, + 149, + 504, + 172 + ], + "lines": [ + { + "bbox": [ + 106, + 149, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 106, + 149, + 505, + 162 + ], + "score": 1.0, + "content": "Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 116, + 160, + 277, + 173 + ], + "spans": [ + { + "bbox": [ + 116, + 160, + 277, + 173 + ], + "score": 1.0, + "content": "Wojciech Zaremba. Openai gym, 2016.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 107, + 179, + 504, + 213 + ], + "lines": [ + { + "bbox": [ + 105, + 179, + 505, + 193 + ], + "spans": [ + { + "bbox": [ + 105, + 179, + 505, + 193 + ], + "score": 1.0, + "content": "Sungwoon Choi, Heonseok Ha, Uiwon Hwang, Chanju Kim, Jung-Woo Ha, and S. Yoon. Reinforce-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 191, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 115, + 191, + 505, + 203 + ], + "score": 1.0, + "content": "ment learning based recommender system using biclustering technique. ArXiv, abs/1801.05532,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 201, + 142, + 214 + ], + "spans": [ + { + "bbox": [ + 115, + 201, + 142, + 214 + ], + "score": 1.0, + "content": "2018.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 108, + 221, + 504, + 255 + ], + "lines": [ + { + "bbox": [ + 105, + 220, + 505, + 233 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 505, + 233 + ], + "score": 1.0, + "content": "I. Csiszar. A class of measures of informativity of observation channels. ´ Periodica Mathematica", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 231, + 504, + 245 + ], + "spans": [ + { + "bbox": [ + 115, + 231, + 504, + 245 + ], + "score": 1.0, + "content": "Hungarica, 2(1):191–213, 1972. doi: 10.1007/BF02018661. URL https://doi.org/10.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 116, + 243, + 212, + 254 + ], + "spans": [ + { + "bbox": [ + 116, + 243, + 212, + 254 + ], + "score": 1.0, + "content": "1007/BF02018661.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 262, + 425, + 274 + ], + "lines": [ + { + "bbox": [ + 105, + 261, + 425, + 275 + ], + "spans": [ + { + "bbox": [ + 105, + 261, + 425, + 275 + ], + "score": 1.0, + "content": "R. Fox. Toward provably unbiased temporal-difference value estimation. 2019.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 105, + 281, + 503, + 304 + ], + "lines": [ + { + "bbox": [ + 105, + 280, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 280, + 505, + 295 + ], + "score": 1.0, + "content": "Justin Fu, Aviral Kumar, Ofir Nachum, G. Tucker, and Sergey Levine. D4rl: Datasets for deep", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 291, + 382, + 304 + ], + "spans": [ + { + "bbox": [ + 116, + 291, + 382, + 304 + ], + "score": 1.0, + "content": "data-driven reinforcement learning. ArXiv, abs/2004.07219, 2020.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 104, + 311, + 504, + 334 + ], + "lines": [ + { + "bbox": [ + 105, + 310, + 505, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 310, + 505, + 325 + ], + "score": 1.0, + "content": "Scott Fujimoto, H. V. Hoof, and David Meger. Addressing function approximation error in actor-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 323, + 305, + 334 + ], + "spans": [ + { + "bbox": [ + 116, + 323, + 305, + 334 + ], + "score": 1.0, + "content": "critic methods. ArXiv, abs/1802.09477, 2018a.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 105, + 342, + 504, + 365 + ], + "lines": [ + { + "bbox": [ + 106, + 342, + 505, + 354 + ], + "spans": [ + { + "bbox": [ + 106, + 342, + 505, + 354 + ], + "score": 1.0, + "content": "Scott Fujimoto, David Meger, and Doina Precup. Off-policy deep reinforcement learning without", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 352, + 505, + 366 + ], + "spans": [ + { + "bbox": [ + 115, + 352, + 505, + 366 + ], + "score": 1.0, + "content": "exploration. CoRR, abs/1812.02900, 2018b. URL http://arxiv.org/abs/1812.02900.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 107, + 371, + 505, + 406 + ], + "lines": [ + { + "bbox": [ + 106, + 372, + 504, + 384 + ], + "spans": [ + { + "bbox": [ + 106, + 372, + 504, + 384 + ], + "score": 1.0, + "content": "Arthur Gretton, Karsten M. Borgwardt, Malte J. Rasch, Bernhard Scholkopf, and Alexander J.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 382, + 506, + 396 + ], + "spans": [ + { + "bbox": [ + 115, + 382, + 506, + 396 + ], + "score": 1.0, + "content": "Smola. A kernel approach to comparing distributions. In AAAI, pp. 1637–1641, 2007. URL", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 116, + 393, + 433, + 407 + ], + "spans": [ + { + "bbox": [ + 116, + 393, + 433, + 407 + ], + "score": 1.0, + "content": "http://www.aaai.org/Library/AAAI/2007/aaai07-262.php.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 106, + 412, + 503, + 436 + ], + "lines": [ + { + "bbox": [ + 106, + 413, + 505, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 505, + 426 + ], + "score": 1.0, + "content": "Ishaan Gulrajani, F. Ahmed, Mart´ın Arjovsky, Vincent Dumoulin, and Aaron C. Courville. Improved", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 424, + 295, + 435 + ], + "spans": [ + { + "bbox": [ + 116, + 424, + 295, + 435 + ], + "score": 1.0, + "content": "training of wasserstein gans. In NIPS, 2017.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 107, + 443, + 506, + 477 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 505, + 457 + ], + "score": 1.0, + "content": "Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 455, + 505, + 466 + ], + "spans": [ + { + "bbox": [ + 115, + 455, + 505, + 466 + ], + "score": 1.0, + "content": "maximum entropy deep reinforcement learning with a stochastic actor. CoRR, abs/1801.01290,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 465, + 360, + 478 + ], + "spans": [ + { + "bbox": [ + 115, + 465, + 360, + 478 + ], + "score": 1.0, + "content": "2018a. URL http://arxiv.org/abs/1801.01290.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 107, + 484, + 505, + 529 + ], + "lines": [ + { + "bbox": [ + 106, + 484, + 506, + 497 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 506, + 497 + ], + "score": 1.0, + "content": "Tuomas Haarnoja, Aurick Zhou, Kristian Hartikainen, George Tucker, Sehoon Ha, Jie Tan, Vikash", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 496, + 504, + 507 + ], + "spans": [ + { + "bbox": [ + 115, + 496, + 504, + 507 + ], + "score": 1.0, + "content": "Kumar, Henry Zhu, Abhishek Gupta, Pieter Abbeel, and Sergey Levine. Soft actor-critic algo-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 507, + 504, + 518 + ], + "spans": [ + { + "bbox": [ + 115, + 507, + 504, + 518 + ], + "score": 1.0, + "content": "rithms and applications. CoRR, abs/1812.05905, 2018b. URL http://arxiv.org/abs/", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 116, + 518, + 181, + 529 + ], + "spans": [ + { + "bbox": [ + 116, + 518, + 181, + 529 + ], + "score": 1.0, + "content": "1812.05905.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 107, + 536, + 504, + 570 + ], + "lines": [ + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "score": 1.0, + "content": "I. Higgins, Lo¨ıc Matthey, A. Pal, C. Burgess, Xavier Glorot, M. Botvinick, S. Mohamed, and", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 116, + 547, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 116, + 547, + 505, + 560 + ], + "score": 1.0, + "content": "Alexander Lerchner. beta-vae: Learning basic visual concepts with a constrained variational", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 559, + 228, + 570 + ], + "spans": [ + { + "bbox": [ + 116, + 559, + 228, + 570 + ], + "score": 1.0, + "content": "framework. In ICLR, 2017.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 106, + 577, + 505, + 611 + ], + "lines": [ + { + "bbox": [ + 105, + 577, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 505, + 591 + ], + "score": 1.0, + "content": "Michael Janner, Justin Fu, Marvin Zhang, and Sergey Levine. When to trust your model: Model-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 588, + 504, + 601 + ], + "spans": [ + { + "bbox": [ + 115, + 588, + 504, + 601 + ], + "score": 1.0, + "content": "based policy optimization. CoRR, abs/1906.08253, 2019. URL http://arxiv.org/abs/", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 599, + 181, + 612 + ], + "spans": [ + { + "bbox": [ + 116, + 599, + 181, + 612 + ], + "score": 1.0, + "content": "1906.08253.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 104, + 618, + 504, + 642 + ], + "lines": [ + { + "bbox": [ + 105, + 618, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 505, + 632 + ], + "score": 1.0, + "content": "Liyiming Ke, M. Barnes, W. Sun, Gilwoo Lee, S. Choudhury, and S. Srinivasa. Imitation learning", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 116, + 630, + 360, + 642 + ], + "spans": [ + { + "bbox": [ + 116, + 630, + 360, + 642 + ], + "score": 1.0, + "content": "as f-divergence minimization. ArXiv, abs/1905.12888, 2019.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37.5 + }, + { + "type": "text", + "bbox": [ + 106, + 649, + 503, + 672 + ], + "lines": [ + { + "bbox": [ + 105, + 648, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 465, + 661 + ], + "score": 1.0, + "content": "Rahul Kidambi, Aravind Rajeswaran, Praneeth Netrapalli, and Thorsten Joachims. Morel", + "type": "text" + }, + { + "bbox": [ + 466, + 651, + 473, + 658 + ], + "score": 0.3, + "content": ":", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 648, + 505, + 661 + ], + "score": 1.0, + "content": "Model-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 116, + 659, + 291, + 672 + ], + "spans": [ + { + "bbox": [ + 116, + 659, + 291, + 672 + ], + "score": 1.0, + "content": "based offline reinforcement learning, 2020.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39.5 + }, + { + "type": "text", + "bbox": [ + 106, + 679, + 504, + 702 + ], + "lines": [ + { + "bbox": [ + 105, + 677, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 693 + ], + "score": 1.0, + "content": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 116, + 690, + 206, + 703 + ], + "spans": [ + { + "bbox": [ + 116, + 690, + 206, + 703 + ], + "score": 1.0, + "content": "abs/1412.6980, 2015.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 722 + ], + "score": 1.0, + "content": "Diederik P. Kingma and Max Welling. Auto-encoding variational bayes. CoRR, abs/1312.6114,", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 114, + 719, + 144, + 733 + ], + "spans": [ + { + "bbox": [ + 114, + 719, + 144, + 733 + ], + "score": 1.0, + "content": "2014.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43.5 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "10", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 26, + 307, + 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 2021", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 176, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 176, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 176, + 94 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 100, + 503, + 112 + ], + "lines": [ + { + "bbox": [ + 105, + 98, + 505, + 114 + ], + "spans": [ + { + "bbox": [ + 105, + 98, + 505, + 114 + ], + "score": 1.0, + "content": "Abien Fred Agarap. Deep learning using rectified linear units (relu). ArXiv, abs/1803.08375, 2018.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1, + "bbox_fs": [ + 105, + 98, + 505, + 114 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 119, + 504, + 142 + ], + "lines": [ + { + "bbox": [ + 106, + 119, + 505, + 132 + ], + "spans": [ + { + "bbox": [ + 106, + 119, + 505, + 132 + ], + "score": 1.0, + "content": "Arthur Argenson and Gabriel Dulac-Arnold. Model-based offline planning. ArXiv, abs/2008.05556,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 114, + 128, + 143, + 144 + ], + "spans": [ + { + "bbox": [ + 114, + 128, + 143, + 144 + ], + "score": 1.0, + "content": "2020.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5, + "bbox_fs": [ + 106, + 119, + 505, + 144 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 149, + 504, + 172 + ], + "lines": [ + { + "bbox": [ + 106, + 149, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 106, + 149, + 505, + 162 + ], + "score": 1.0, + "content": "Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 116, + 160, + 277, + 173 + ], + "spans": [ + { + "bbox": [ + 116, + 160, + 277, + 173 + ], + "score": 1.0, + "content": "Wojciech Zaremba. Openai gym, 2016.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5, + "bbox_fs": [ + 106, + 149, + 505, + 173 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 179, + 504, + 213 + ], + "lines": [ + { + "bbox": [ + 105, + 179, + 505, + 193 + ], + "spans": [ + { + "bbox": [ + 105, + 179, + 505, + 193 + ], + "score": 1.0, + "content": "Sungwoon Choi, Heonseok Ha, Uiwon Hwang, Chanju Kim, Jung-Woo Ha, and S. Yoon. Reinforce-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 191, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 115, + 191, + 505, + 203 + ], + "score": 1.0, + "content": "ment learning based recommender system using biclustering technique. ArXiv, abs/1801.05532,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 201, + 142, + 214 + ], + "spans": [ + { + "bbox": [ + 115, + 201, + 142, + 214 + ], + "score": 1.0, + "content": "2018.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7, + "bbox_fs": [ + 105, + 179, + 505, + 214 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 221, + 504, + 255 + ], + "lines": [ + { + "bbox": [ + 105, + 220, + 505, + 233 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 505, + 233 + ], + "score": 1.0, + "content": "I. Csiszar. A class of measures of informativity of observation channels. ´ Periodica Mathematica", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 231, + 504, + 245 + ], + "spans": [ + { + "bbox": [ + 115, + 231, + 504, + 245 + ], + "score": 1.0, + "content": "Hungarica, 2(1):191–213, 1972. doi: 10.1007/BF02018661. URL https://doi.org/10.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 116, + 243, + 212, + 254 + ], + "spans": [ + { + "bbox": [ + 116, + 243, + 212, + 254 + ], + "score": 1.0, + "content": "1007/BF02018661.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10, + "bbox_fs": [ + 105, + 220, + 505, + 254 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 262, + 425, + 274 + ], + "lines": [ + { + "bbox": [ + 105, + 261, + 425, + 275 + ], + "spans": [ + { + "bbox": [ + 105, + 261, + 425, + 275 + ], + "score": 1.0, + "content": "R. Fox. Toward provably unbiased temporal-difference value estimation. 2019.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 261, + 425, + 275 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 281, + 503, + 304 + ], + "lines": [ + { + "bbox": [ + 105, + 280, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 280, + 505, + 295 + ], + "score": 1.0, + "content": "Justin Fu, Aviral Kumar, Ofir Nachum, G. Tucker, and Sergey Levine. D4rl: Datasets for deep", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 291, + 382, + 304 + ], + "spans": [ + { + "bbox": [ + 116, + 291, + 382, + 304 + ], + "score": 1.0, + "content": "data-driven reinforcement learning. ArXiv, abs/2004.07219, 2020.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5, + "bbox_fs": [ + 105, + 280, + 505, + 304 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 311, + 504, + 334 + ], + "lines": [ + { + "bbox": [ + 105, + 310, + 505, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 310, + 505, + 325 + ], + "score": 1.0, + "content": "Scott Fujimoto, H. V. Hoof, and David Meger. Addressing function approximation error in actor-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 323, + 305, + 334 + ], + "spans": [ + { + "bbox": [ + 116, + 323, + 305, + 334 + ], + "score": 1.0, + "content": "critic methods. ArXiv, abs/1802.09477, 2018a.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 310, + 505, + 334 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 342, + 504, + 365 + ], + "lines": [ + { + "bbox": [ + 106, + 342, + 505, + 354 + ], + "spans": [ + { + "bbox": [ + 106, + 342, + 505, + 354 + ], + "score": 1.0, + "content": "Scott Fujimoto, David Meger, and Doina Precup. Off-policy deep reinforcement learning without", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 352, + 505, + 366 + ], + "spans": [ + { + "bbox": [ + 115, + 352, + 505, + 366 + ], + "score": 1.0, + "content": "exploration. CoRR, abs/1812.02900, 2018b. URL http://arxiv.org/abs/1812.02900.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5, + "bbox_fs": [ + 106, + 342, + 505, + 366 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 371, + 505, + 406 + ], + "lines": [ + { + "bbox": [ + 106, + 372, + 504, + 384 + ], + "spans": [ + { + "bbox": [ + 106, + 372, + 504, + 384 + ], + "score": 1.0, + "content": "Arthur Gretton, Karsten M. Borgwardt, Malte J. Rasch, Bernhard Scholkopf, and Alexander J.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 382, + 506, + 396 + ], + "spans": [ + { + "bbox": [ + 115, + 382, + 506, + 396 + ], + "score": 1.0, + "content": "Smola. A kernel approach to comparing distributions. In AAAI, pp. 1637–1641, 2007. URL", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 116, + 393, + 433, + 407 + ], + "spans": [ + { + "bbox": [ + 116, + 393, + 433, + 407 + ], + "score": 1.0, + "content": "http://www.aaai.org/Library/AAAI/2007/aaai07-262.php.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20, + "bbox_fs": [ + 106, + 372, + 506, + 407 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 412, + 503, + 436 + ], + "lines": [ + { + "bbox": [ + 106, + 413, + 505, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 505, + 426 + ], + "score": 1.0, + "content": "Ishaan Gulrajani, F. Ahmed, Mart´ın Arjovsky, Vincent Dumoulin, and Aaron C. Courville. Improved", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 424, + 295, + 435 + ], + "spans": [ + { + "bbox": [ + 116, + 424, + 295, + 435 + ], + "score": 1.0, + "content": "training of wasserstein gans. In NIPS, 2017.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 106, + 413, + 505, + 435 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 443, + 506, + 477 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 505, + 457 + ], + "score": 1.0, + "content": "Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 455, + 505, + 466 + ], + "spans": [ + { + "bbox": [ + 115, + 455, + 505, + 466 + ], + "score": 1.0, + "content": "maximum entropy deep reinforcement learning with a stochastic actor. CoRR, abs/1801.01290,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 465, + 360, + 478 + ], + "spans": [ + { + "bbox": [ + 115, + 465, + 360, + 478 + ], + "score": 1.0, + "content": "2018a. URL http://arxiv.org/abs/1801.01290.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 442, + 505, + 478 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 484, + 505, + 529 + ], + "lines": [ + { + "bbox": [ + 106, + 484, + 506, + 497 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 506, + 497 + ], + "score": 1.0, + "content": "Tuomas Haarnoja, Aurick Zhou, Kristian Hartikainen, George Tucker, Sehoon Ha, Jie Tan, Vikash", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 496, + 504, + 507 + ], + "spans": [ + { + "bbox": [ + 115, + 496, + 504, + 507 + ], + "score": 1.0, + "content": "Kumar, Henry Zhu, Abhishek Gupta, Pieter Abbeel, and Sergey Levine. Soft actor-critic algo-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 507, + 504, + 518 + ], + "spans": [ + { + "bbox": [ + 115, + 507, + 504, + 518 + ], + "score": 1.0, + "content": "rithms and applications. CoRR, abs/1812.05905, 2018b. URL http://arxiv.org/abs/", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 116, + 518, + 181, + 529 + ], + "spans": [ + { + "bbox": [ + 116, + 518, + 181, + 529 + ], + "score": 1.0, + "content": "1812.05905.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28.5, + "bbox_fs": [ + 106, + 484, + 506, + 529 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 536, + 504, + 570 + ], + "lines": [ + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "score": 1.0, + "content": "I. Higgins, Lo¨ıc Matthey, A. Pal, C. Burgess, Xavier Glorot, M. Botvinick, S. Mohamed, and", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 116, + 547, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 116, + 547, + 505, + 560 + ], + "score": 1.0, + "content": "Alexander Lerchner. beta-vae: Learning basic visual concepts with a constrained variational", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 559, + 228, + 570 + ], + "spans": [ + { + "bbox": [ + 116, + 559, + 228, + 570 + ], + "score": 1.0, + "content": "framework. In ICLR, 2017.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32, + "bbox_fs": [ + 105, + 536, + 505, + 570 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 577, + 505, + 611 + ], + "lines": [ + { + "bbox": [ + 105, + 577, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 505, + 591 + ], + "score": 1.0, + "content": "Michael Janner, Justin Fu, Marvin Zhang, and Sergey Levine. When to trust your model: Model-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 588, + 504, + 601 + ], + "spans": [ + { + "bbox": [ + 115, + 588, + 504, + 601 + ], + "score": 1.0, + "content": "based policy optimization. CoRR, abs/1906.08253, 2019. URL http://arxiv.org/abs/", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 599, + 181, + 612 + ], + "spans": [ + { + "bbox": [ + 116, + 599, + 181, + 612 + ], + "score": 1.0, + "content": "1906.08253.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 577, + 505, + 612 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 618, + 504, + 642 + ], + "lines": [ + { + "bbox": [ + 105, + 618, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 505, + 632 + ], + "score": 1.0, + "content": "Liyiming Ke, M. Barnes, W. Sun, Gilwoo Lee, S. Choudhury, and S. Srinivasa. Imitation learning", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 116, + 630, + 360, + 642 + ], + "spans": [ + { + "bbox": [ + 116, + 630, + 360, + 642 + ], + "score": 1.0, + "content": "as f-divergence minimization. ArXiv, abs/1905.12888, 2019.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37.5, + "bbox_fs": [ + 105, + 618, + 505, + 642 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 649, + 503, + 672 + ], + "lines": [ + { + "bbox": [ + 105, + 648, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 465, + 661 + ], + "score": 1.0, + "content": "Rahul Kidambi, Aravind Rajeswaran, Praneeth Netrapalli, and Thorsten Joachims. Morel", + "type": "text" + }, + { + "bbox": [ + 466, + 651, + 473, + 658 + ], + "score": 0.3, + "content": ":", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 648, + 505, + 661 + ], + "score": 1.0, + "content": "Model-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 116, + 659, + 291, + 672 + ], + "spans": [ + { + "bbox": [ + 116, + 659, + 291, + 672 + ], + "score": 1.0, + "content": "based offline reinforcement learning, 2020.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39.5, + "bbox_fs": [ + 105, + 648, + 505, + 672 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 679, + 504, + 702 + ], + "lines": [ + { + "bbox": [ + 105, + 677, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 693 + ], + "score": 1.0, + "content": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 116, + 690, + 206, + 703 + ], + "spans": [ + { + "bbox": [ + 116, + 690, + 206, + 703 + ], + "score": 1.0, + "content": "abs/1412.6980, 2015.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5, + "bbox_fs": [ + 105, + 677, + 505, + 703 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 722 + ], + "score": 1.0, + "content": "Diederik P. Kingma and Max Welling. Auto-encoding variational bayes. CoRR, abs/1312.6114,", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 114, + 719, + 144, + 733 + ], + "spans": [ + { + "bbox": [ + 114, + 719, + 144, + 733 + ], + "score": 1.0, + "content": "2014.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43.5, + "bbox_fs": [ + 105, + 708, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 115 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "Aviral Kumar, Justin Fu, George Tucker, and Sergey Levine. Stabilizing off-policy q-learning via", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 93, + 504, + 107 + ], + "spans": [ + { + "bbox": [ + 115, + 93, + 504, + 107 + ], + "score": 1.0, + "content": "bootstrapping error reduction. CoRR, abs/1906.00949, 2019. URL http://arxiv.org/", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 116, + 105, + 206, + 115 + ], + "spans": [ + { + "bbox": [ + 116, + 105, + 206, + 115 + ], + "score": 1.0, + "content": "abs/1906.00949.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 122, + 504, + 145 + ], + "lines": [ + { + "bbox": [ + 105, + 121, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 105, + 121, + 505, + 136 + ], + "score": 1.0, + "content": "Aviral Kumar, Aurick Zhou, G. Tucker, and Sergey Levine. Conservative q-learning for offline", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 134, + 335, + 146 + ], + "spans": [ + { + "bbox": [ + 115, + 134, + 335, + 146 + ], + "score": 1.0, + "content": "reinforcement learning. ArXiv, abs/2006.04779, 2020.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 152, + 503, + 175 + ], + "lines": [ + { + "bbox": [ + 106, + 152, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 106, + 152, + 505, + 165 + ], + "score": 1.0, + "content": "Byung-Jun Lee, Jongmin Lee, Peter Vrancx, DongHo Kim, and Kee-Eung Kim. Batch reinforce-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 163, + 326, + 175 + ], + "spans": [ + { + "bbox": [ + 115, + 163, + 326, + 175 + ], + "score": 1.0, + "content": "ment learning with hyperparameter gradients. 2020.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 105, + 181, + 503, + 204 + ], + "lines": [ + { + "bbox": [ + 106, + 181, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 106, + 181, + 505, + 194 + ], + "score": 1.0, + "content": "Sergey Levine, Aviral Kumar, George Tucker, and Justin Fu. Offline reinforcement learning: Tuto-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 192, + 432, + 205 + ], + "spans": [ + { + "bbox": [ + 115, + 192, + 432, + 205 + ], + "score": 1.0, + "content": "rial, review, and perspectives on open problems. ArXiv, abs/2005.01643, 2020.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 107, + 210, + 503, + 244 + ], + "lines": [ + { + "bbox": [ + 105, + 209, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 505, + 225 + ], + "score": 1.0, + "content": "Timothy P. Lillicrap, Jonathan J. Hunt, Alexander Pritzel, Nicolas Manfred Otto Heess, Tom Erez,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 116, + 221, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 116, + 221, + 505, + 234 + ], + "score": 1.0, + "content": "Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learn-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 116, + 233, + 257, + 244 + ], + "spans": [ + { + "bbox": [ + 116, + 233, + 257, + 244 + ], + "score": 1.0, + "content": "ing. CoRR, abs/1509.02971, 2016.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 104, + 250, + 502, + 263 + ], + "lines": [ + { + "bbox": [ + 105, + 250, + 501, + 264 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 501, + 264 + ], + "score": 1.0, + "content": "Long-Ji Lin. Reinforcement Learning for Robots Using Neural Networks. PhD thesis, USA, 1992.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 269, + 504, + 304 + ], + "lines": [ + { + "bbox": [ + 106, + 270, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 505, + 282 + ], + "score": 1.0, + "content": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 280, + 505, + 294 + ], + "spans": [ + { + "bbox": [ + 116, + 280, + 505, + 294 + ], + "score": 1.0, + "content": "Wierstra, and Martin A. Riedmiller. Playing atari with deep reinforcement learning. CoRR,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 291, + 413, + 304 + ], + "spans": [ + { + "bbox": [ + 115, + 291, + 413, + 304 + ], + "score": 1.0, + "content": "abs/1312.5602, 2013. URL http://arxiv.org/abs/1312.5602.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 105, + 309, + 504, + 343 + ], + "lines": [ + { + "bbox": [ + 105, + 308, + 505, + 324 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 505, + 324 + ], + "score": 1.0, + "content": "A. Rajeswaran, V. Kumar, Abhishek Gupta, John Schulman, E. Todorov, and S. Levine. Learning", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 116, + 321, + 505, + 333 + ], + "spans": [ + { + "bbox": [ + 116, + 321, + 505, + 333 + ], + "score": 1.0, + "content": "complex dexterous manipulation with deep reinforcement learning and demonstrations. ArXiv,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 116, + 332, + 209, + 343 + ], + "spans": [ + { + "bbox": [ + 116, + 332, + 209, + 343 + ], + "score": 1.0, + "content": "abs/1709.10087, 2018.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 106, + 350, + 504, + 383 + ], + "lines": [ + { + "bbox": [ + 106, + 349, + 506, + 363 + ], + "spans": [ + { + "bbox": [ + 106, + 349, + 506, + 363 + ], + "score": 1.0, + "content": "Stephane Ross, Geoffrey J. Gordon, and J. Andrew Bagnell. No-regret reductions for imitation ´", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 360, + 504, + 375 + ], + "spans": [ + { + "bbox": [ + 115, + 360, + 504, + 375 + ], + "score": 1.0, + "content": "learning and structured prediction. CoRR, abs/1011.0686, 2010. URL http://arxiv.org/", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 116, + 373, + 200, + 383 + ], + "spans": [ + { + "bbox": [ + 116, + 373, + 200, + 383 + ], + "score": 1.0, + "content": "abs/1011.0686.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 109, + 390, + 502, + 424 + ], + "lines": [ + { + "bbox": [ + 107, + 390, + 504, + 404 + ], + "spans": [ + { + "bbox": [ + 107, + 390, + 504, + 404 + ], + "score": 1.0, + "content": "Noah Siegel, Jost Tobias Springenberg, Felix Berkenkamp, Abbas Abdolmaleki, Michael Neunert,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 402, + 504, + 414 + ], + "spans": [ + { + "bbox": [ + 116, + 402, + 504, + 414 + ], + "score": 1.0, + "content": "T. Lampe, Roland Hafner, and Martin A. Riedmiller. Keep doing what worked: Behavioral", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 116, + 412, + 446, + 426 + ], + "spans": [ + { + "bbox": [ + 116, + 412, + 446, + 426 + ], + "score": 1.0, + "content": "modelling priors for offline reinforcement learning. ArXiv, abs/2002.08396, 2020.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 106, + 431, + 505, + 497 + ], + "lines": [ + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "score": 1.0, + "content": "David Silver, Aja Huang, Christopher J. Maddison, Arthur Guez, Laurent Sifre, George van den", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 441, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 115, + 441, + 506, + 455 + ], + "score": 1.0, + "content": "Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 116, + 453, + 504, + 465 + ], + "spans": [ + { + "bbox": [ + 116, + 453, + 504, + 465 + ], + "score": 1.0, + "content": "Sander Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy Lilli-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 464, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 115, + 464, + 505, + 477 + ], + "score": 1.0, + "content": "crap, Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 474, + 505, + 488 + ], + "spans": [ + { + "bbox": [ + 115, + 474, + 505, + 488 + ], + "score": 1.0, + "content": "game of go with deep neural networks and tree search. Nature, 529:484–503, 2016. URL http:", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 117, + 487, + 504, + 498 + ], + "spans": [ + { + "bbox": [ + 117, + 487, + 504, + 498 + ], + "score": 1.0, + "content": "//www.nature.com/nature/journal/v529/n7587/full/nature16961.html.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 106, + 504, + 503, + 527 + ], + "lines": [ + { + "bbox": [ + 105, + 504, + 505, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 505, + 516 + ], + "score": 1.0, + "content": "Richard S. Sutton and Andrew G. Barto. Reinforcement Learning: An Introduction. A Bradford", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 515, + 344, + 527 + ], + "spans": [ + { + "bbox": [ + 115, + 515, + 344, + 527 + ], + "score": 1.0, + "content": "Book, Cambridge, MA, USA, 2018. ISBN 0262039249.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31.5 + }, + { + "type": "text", + "bbox": [ + 107, + 533, + 505, + 633 + ], + "lines": [ + { + "bbox": [ + 106, + 533, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 106, + 533, + 506, + 546 + ], + "score": 1.0, + "content": "Oriol Vinyals, Igor Babuschkin, Junyoung Chung, Michael Mathieu, Max Jaderberg, Wojtek", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 116, + 544, + 506, + 558 + ], + "spans": [ + { + "bbox": [ + 116, + 544, + 506, + 558 + ], + "score": 1.0, + "content": "Czarnecki, Andrew Dudzik, Aja Huang, Petko Georgiev, Richard Powell, Timo Ewalds,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 555, + 504, + 568 + ], + "spans": [ + { + "bbox": [ + 115, + 555, + 504, + 568 + ], + "score": 1.0, + "content": "Dan Horgan, Manuel Kroiss, Ivo Danihelka, John Agapiou, Junhyuk Oh, Valentin Dal-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 115, + 565, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 115, + 565, + 505, + 579 + ], + "score": 1.0, + "content": "ibard, David Choi, Laurent Sifre, Yury Sulsky, Sasha Vezhnevets, James Molloy, Trevor", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 576, + 506, + 591 + ], + "spans": [ + { + "bbox": [ + 115, + 576, + 506, + 591 + ], + "score": 1.0, + "content": "Cai, David Budden, Tom Paine, Caglar Gulcehre, Ziyu Wang, Tobias Pfaff, Toby Pohlen,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 587, + 505, + 602 + ], + "spans": [ + { + "bbox": [ + 115, + 587, + 505, + 602 + ], + "score": 1.0, + "content": "Dani Yogatama, Julia Cohen, Katrina McKinney, Oliver Smith, Tom Schaul, Timothy Lil-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 115, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "licrap, Chris Apps, Koray Kavukcuoglu, Demis Hassabis, and David Silver. AlphaStar:", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 610, + 504, + 623 + ], + "spans": [ + { + "bbox": [ + 115, + 610, + 504, + 623 + ], + "score": 1.0, + "content": "Mastering the Real-Time Strategy Game StarCraft II. https://deepmind.com/blog/", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 115, + 621, + 491, + 634 + ], + "spans": [ + { + "bbox": [ + 115, + 621, + 491, + 634 + ], + "score": 1.0, + "content": "alphastar-mastering-real-time-strategy-game-starcraft-ii/, 2019.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 640, + 504, + 673 + ], + "lines": [ + { + "bbox": [ + 105, + 639, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 505, + 653 + ], + "score": 1.0, + "content": "Ziyu Wang, A. Novikov, Konrad Zolna, Jost Tobias Springenberg, Scott Reed, B. Shahriari,", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 116, + 651, + 505, + 663 + ], + "spans": [ + { + "bbox": [ + 116, + 651, + 505, + 663 + ], + "score": 1.0, + "content": "N. Siegel, Josh Merel, Caglar Gulcehre, Nicolas Heess, and N. D. Freitas. Critic regularized", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 116, + 662, + 285, + 673 + ], + "spans": [ + { + "bbox": [ + 116, + 662, + 285, + 673 + ], + "score": 1.0, + "content": "regression. ArXiv, abs/2006.15134, 2020.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 107, + 680, + 503, + 703 + ], + "lines": [ + { + "bbox": [ + 105, + 677, + 506, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 695 + ], + "score": 1.0, + "content": "Yifan Wu, George Tucker, and Ofir Nachum. Behavior regularized offline reinforcement learning,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 114, + 690, + 143, + 704 + ], + "spans": [ + { + "bbox": [ + 114, + 690, + 143, + 704 + ], + "score": 1.0, + "content": "2019.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45.5 + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 502, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "Tianhe Yu, Garrett Thomas, Lantao Yu, Stefano Ermon, James Zou, Sergey Levine, Chelsea Finn,", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 116, + 720, + 405, + 733 + ], + "spans": [ + { + "bbox": [ + 116, + 720, + 405, + 733 + ], + "score": 1.0, + "content": "and Tengyu Ma. Mopo: Model-based offline policy optimization, 2020.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47.5 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 115 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "Aviral Kumar, Justin Fu, George Tucker, and Sergey Levine. Stabilizing off-policy q-learning via", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 93, + 504, + 107 + ], + "spans": [ + { + "bbox": [ + 115, + 93, + 504, + 107 + ], + "score": 1.0, + "content": "bootstrapping error reduction. CoRR, abs/1906.00949, 2019. URL http://arxiv.org/", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 116, + 105, + 206, + 115 + ], + "spans": [ + { + "bbox": [ + 116, + 105, + 206, + 115 + ], + "score": 1.0, + "content": "abs/1906.00949.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 105, + 81, + 505, + 115 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 122, + 504, + 145 + ], + "lines": [ + { + "bbox": [ + 105, + 121, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 105, + 121, + 505, + 136 + ], + "score": 1.0, + "content": "Aviral Kumar, Aurick Zhou, G. Tucker, and Sergey Levine. Conservative q-learning for offline", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 134, + 335, + 146 + ], + "spans": [ + { + "bbox": [ + 115, + 134, + 335, + 146 + ], + "score": 1.0, + "content": "reinforcement learning. ArXiv, abs/2006.04779, 2020.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 121, + 505, + 146 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 152, + 503, + 175 + ], + "lines": [ + { + "bbox": [ + 106, + 152, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 106, + 152, + 505, + 165 + ], + "score": 1.0, + "content": "Byung-Jun Lee, Jongmin Lee, Peter Vrancx, DongHo Kim, and Kee-Eung Kim. Batch reinforce-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 163, + 326, + 175 + ], + "spans": [ + { + "bbox": [ + 115, + 163, + 326, + 175 + ], + "score": 1.0, + "content": "ment learning with hyperparameter gradients. 2020.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5, + "bbox_fs": [ + 106, + 152, + 505, + 175 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 181, + 503, + 204 + ], + "lines": [ + { + "bbox": [ + 106, + 181, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 106, + 181, + 505, + 194 + ], + "score": 1.0, + "content": "Sergey Levine, Aviral Kumar, George Tucker, and Justin Fu. Offline reinforcement learning: Tuto-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 192, + 432, + 205 + ], + "spans": [ + { + "bbox": [ + 115, + 192, + 432, + 205 + ], + "score": 1.0, + "content": "rial, review, and perspectives on open problems. ArXiv, abs/2005.01643, 2020.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5, + "bbox_fs": [ + 106, + 181, + 505, + 205 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 210, + 503, + 244 + ], + "lines": [ + { + "bbox": [ + 105, + 209, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 505, + 225 + ], + "score": 1.0, + "content": "Timothy P. Lillicrap, Jonathan J. Hunt, Alexander Pritzel, Nicolas Manfred Otto Heess, Tom Erez,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 116, + 221, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 116, + 221, + 505, + 234 + ], + "score": 1.0, + "content": "Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learn-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 116, + 233, + 257, + 244 + ], + "spans": [ + { + "bbox": [ + 116, + 233, + 257, + 244 + ], + "score": 1.0, + "content": "ing. CoRR, abs/1509.02971, 2016.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10, + "bbox_fs": [ + 105, + 209, + 505, + 244 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 250, + 502, + 263 + ], + "lines": [ + { + "bbox": [ + 105, + 250, + 501, + 264 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 501, + 264 + ], + "score": 1.0, + "content": "Long-Ji Lin. Reinforcement Learning for Robots Using Neural Networks. PhD thesis, USA, 1992.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 250, + 501, + 264 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 269, + 504, + 304 + ], + "lines": [ + { + "bbox": [ + 106, + 270, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 505, + 282 + ], + "score": 1.0, + "content": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 280, + 505, + 294 + ], + "spans": [ + { + "bbox": [ + 116, + 280, + 505, + 294 + ], + "score": 1.0, + "content": "Wierstra, and Martin A. Riedmiller. Playing atari with deep reinforcement learning. CoRR,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 291, + 413, + 304 + ], + "spans": [ + { + "bbox": [ + 115, + 291, + 413, + 304 + ], + "score": 1.0, + "content": "abs/1312.5602, 2013. URL http://arxiv.org/abs/1312.5602.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14, + "bbox_fs": [ + 106, + 270, + 505, + 304 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 309, + 504, + 343 + ], + "lines": [ + { + "bbox": [ + 105, + 308, + 505, + 324 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 505, + 324 + ], + "score": 1.0, + "content": "A. Rajeswaran, V. Kumar, Abhishek Gupta, John Schulman, E. Todorov, and S. Levine. Learning", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 116, + 321, + 505, + 333 + ], + "spans": [ + { + "bbox": [ + 116, + 321, + 505, + 333 + ], + "score": 1.0, + "content": "complex dexterous manipulation with deep reinforcement learning and demonstrations. ArXiv,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 116, + 332, + 209, + 343 + ], + "spans": [ + { + "bbox": [ + 116, + 332, + 209, + 343 + ], + "score": 1.0, + "content": "abs/1709.10087, 2018.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 308, + 505, + 343 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 350, + 504, + 383 + ], + "lines": [ + { + "bbox": [ + 106, + 349, + 506, + 363 + ], + "spans": [ + { + "bbox": [ + 106, + 349, + 506, + 363 + ], + "score": 1.0, + "content": "Stephane Ross, Geoffrey J. Gordon, and J. Andrew Bagnell. No-regret reductions for imitation ´", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 360, + 504, + 375 + ], + "spans": [ + { + "bbox": [ + 115, + 360, + 504, + 375 + ], + "score": 1.0, + "content": "learning and structured prediction. CoRR, abs/1011.0686, 2010. URL http://arxiv.org/", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 116, + 373, + 200, + 383 + ], + "spans": [ + { + "bbox": [ + 116, + 373, + 200, + 383 + ], + "score": 1.0, + "content": "abs/1011.0686.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20, + "bbox_fs": [ + 106, + 349, + 506, + 383 + ] + }, + { + "type": "text", + "bbox": [ + 109, + 390, + 502, + 424 + ], + "lines": [ + { + "bbox": [ + 107, + 390, + 504, + 404 + ], + "spans": [ + { + "bbox": [ + 107, + 390, + 504, + 404 + ], + "score": 1.0, + "content": "Noah Siegel, Jost Tobias Springenberg, Felix Berkenkamp, Abbas Abdolmaleki, Michael Neunert,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 402, + 504, + 414 + ], + "spans": [ + { + "bbox": [ + 116, + 402, + 504, + 414 + ], + "score": 1.0, + "content": "T. Lampe, Roland Hafner, and Martin A. Riedmiller. Keep doing what worked: Behavioral", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 116, + 412, + 446, + 426 + ], + "spans": [ + { + "bbox": [ + 116, + 412, + 446, + 426 + ], + "score": 1.0, + "content": "modelling priors for offline reinforcement learning. ArXiv, abs/2002.08396, 2020.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23, + "bbox_fs": [ + 107, + 390, + 504, + 426 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 431, + 505, + 497 + ], + "lines": [ + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "score": 1.0, + "content": "David Silver, Aja Huang, Christopher J. Maddison, Arthur Guez, Laurent Sifre, George van den", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 441, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 115, + 441, + 506, + 455 + ], + "score": 1.0, + "content": "Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 116, + 453, + 504, + 465 + ], + "spans": [ + { + "bbox": [ + 116, + 453, + 504, + 465 + ], + "score": 1.0, + "content": "Sander Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy Lilli-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 464, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 115, + 464, + 505, + 477 + ], + "score": 1.0, + "content": "crap, Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 474, + 505, + 488 + ], + "spans": [ + { + "bbox": [ + 115, + 474, + 505, + 488 + ], + "score": 1.0, + "content": "game of go with deep neural networks and tree search. Nature, 529:484–503, 2016. URL http:", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 117, + 487, + 504, + 498 + ], + "spans": [ + { + "bbox": [ + 117, + 487, + 504, + 498 + ], + "score": 1.0, + "content": "//www.nature.com/nature/journal/v529/n7587/full/nature16961.html.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 430, + 506, + 498 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 504, + 503, + 527 + ], + "lines": [ + { + "bbox": [ + 105, + 504, + 505, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 505, + 516 + ], + "score": 1.0, + "content": "Richard S. Sutton and Andrew G. Barto. Reinforcement Learning: An Introduction. A Bradford", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 515, + 344, + 527 + ], + "spans": [ + { + "bbox": [ + 115, + 515, + 344, + 527 + ], + "score": 1.0, + "content": "Book, Cambridge, MA, USA, 2018. ISBN 0262039249.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31.5, + "bbox_fs": [ + 105, + 504, + 505, + 527 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 533, + 505, + 633 + ], + "lines": [ + { + "bbox": [ + 106, + 533, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 106, + 533, + 506, + 546 + ], + "score": 1.0, + "content": "Oriol Vinyals, Igor Babuschkin, Junyoung Chung, Michael Mathieu, Max Jaderberg, Wojtek", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 116, + 544, + 506, + 558 + ], + "spans": [ + { + "bbox": [ + 116, + 544, + 506, + 558 + ], + "score": 1.0, + "content": "Czarnecki, Andrew Dudzik, Aja Huang, Petko Georgiev, Richard Powell, Timo Ewalds,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 555, + 504, + 568 + ], + "spans": [ + { + "bbox": [ + 115, + 555, + 504, + 568 + ], + "score": 1.0, + "content": "Dan Horgan, Manuel Kroiss, Ivo Danihelka, John Agapiou, Junhyuk Oh, Valentin Dal-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 115, + 565, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 115, + 565, + 505, + 579 + ], + "score": 1.0, + "content": "ibard, David Choi, Laurent Sifre, Yury Sulsky, Sasha Vezhnevets, James Molloy, Trevor", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 576, + 506, + 591 + ], + "spans": [ + { + "bbox": [ + 115, + 576, + 506, + 591 + ], + "score": 1.0, + "content": "Cai, David Budden, Tom Paine, Caglar Gulcehre, Ziyu Wang, Tobias Pfaff, Toby Pohlen,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 587, + 505, + 602 + ], + "spans": [ + { + "bbox": [ + 115, + 587, + 505, + 602 + ], + "score": 1.0, + "content": "Dani Yogatama, Julia Cohen, Katrina McKinney, Oliver Smith, Tom Schaul, Timothy Lil-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 115, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "licrap, Chris Apps, Koray Kavukcuoglu, Demis Hassabis, and David Silver. AlphaStar:", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 610, + 504, + 623 + ], + "spans": [ + { + "bbox": [ + 115, + 610, + 504, + 623 + ], + "score": 1.0, + "content": "Mastering the Real-Time Strategy Game StarCraft II. https://deepmind.com/blog/", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 115, + 621, + 491, + 634 + ], + "spans": [ + { + "bbox": [ + 115, + 621, + 491, + 634 + ], + "score": 1.0, + "content": "alphastar-mastering-real-time-strategy-game-starcraft-ii/, 2019.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 37, + "bbox_fs": [ + 106, + 533, + 506, + 634 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 640, + 504, + 673 + ], + "lines": [ + { + "bbox": [ + 105, + 639, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 505, + 653 + ], + "score": 1.0, + "content": "Ziyu Wang, A. Novikov, Konrad Zolna, Jost Tobias Springenberg, Scott Reed, B. Shahriari,", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 116, + 651, + 505, + 663 + ], + "spans": [ + { + "bbox": [ + 116, + 651, + 505, + 663 + ], + "score": 1.0, + "content": "N. Siegel, Josh Merel, Caglar Gulcehre, Nicolas Heess, and N. D. Freitas. Critic regularized", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 116, + 662, + 285, + 673 + ], + "spans": [ + { + "bbox": [ + 116, + 662, + 285, + 673 + ], + "score": 1.0, + "content": "regression. ArXiv, abs/2006.15134, 2020.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43, + "bbox_fs": [ + 105, + 639, + 505, + 673 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 680, + 503, + 703 + ], + "lines": [ + { + "bbox": [ + 105, + 677, + 506, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 695 + ], + "score": 1.0, + "content": "Yifan Wu, George Tucker, and Ofir Nachum. Behavior regularized offline reinforcement learning,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 114, + 690, + 143, + 704 + ], + "spans": [ + { + "bbox": [ + 114, + 690, + 143, + 704 + ], + "score": 1.0, + "content": "2019.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45.5, + "bbox_fs": [ + 105, + 677, + 506, + 704 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 502, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "Tianhe Yu, Garrett Thomas, Lantao Yu, Stefano Ermon, James Zou, Sergey Levine, Chelsea Finn,", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 116, + 720, + 405, + 733 + ], + "spans": [ + { + "bbox": [ + 116, + 720, + 405, + 733 + ], + "score": 1.0, + "content": "and Tengyu Ma. Mopo: Model-based offline policy optimization, 2020.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47.5, + "bbox_fs": [ + 105, + 708, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 149 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Chi Zhang, Sanmukh R. Kuppannagari, Rajgopal Kannan, and Viktor K. Prasanna. Building hvac", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 115, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "scheduling using reinforcement learning via neural network based model approximation. In Pro-", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 114, + 103, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 114, + 103, + 505, + 119 + ], + "score": 1.0, + "content": "ceedings of the 6th ACM International Conference on Systems for Energy-Efficient Buildings,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 116, + 114, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 116, + 114, + 505, + 128 + ], + "score": 1.0, + "content": "Cities, and Transportation, BuildSys ’19, pp. 287–296, New York, NY, USA, 2019. Associa-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 126, + 506, + 139 + ], + "spans": [ + { + "bbox": [ + 115, + 126, + 506, + 139 + ], + "score": 1.0, + "content": "tion for Computing Machinery. ISBN 9781450370059. doi: 10.1145/3360322.3360861. URL", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 116, + 137, + 354, + 149 + ], + "spans": [ + { + "bbox": [ + 116, + 137, + 354, + 149 + ], + "score": 1.0, + "content": "https://doi.org/10.1145/3360322.3360861.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "12", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 149 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Chi Zhang, Sanmukh R. Kuppannagari, Rajgopal Kannan, and Viktor K. Prasanna. Building hvac", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 115, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "scheduling using reinforcement learning via neural network based model approximation. In Pro-", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 114, + 103, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 114, + 103, + 505, + 119 + ], + "score": 1.0, + "content": "ceedings of the 6th ACM International Conference on Systems for Energy-Efficient Buildings,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 116, + 114, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 116, + 114, + 505, + 128 + ], + "score": 1.0, + "content": "Cities, and Transportation, BuildSys ’19, pp. 287–296, New York, NY, USA, 2019. Associa-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 126, + 506, + 139 + ], + "spans": [ + { + "bbox": [ + 115, + 126, + 506, + 139 + ], + "score": 1.0, + "content": "tion for Computing Machinery. ISBN 9781450370059. doi: 10.1145/3360322.3360861. URL", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 116, + 137, + 354, + 149 + ], + "spans": [ + { + "bbox": [ + 116, + 137, + 354, + 149 + ], + "score": 1.0, + "content": "https://doi.org/10.1145/3360322.3360861.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5, + "bbox_fs": [ + 106, + 82, + 506, + 149 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 149, + 82, + 464, + 252 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 149, + 82, + 464, + 252 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 149, + 82, + 464, + 252 + ], + "spans": [ + { + "bbox": [ + 149, + 82, + 464, + 252 + ], + "score": 0.97, + "type": "image", + "image_path": "a1c91ac49d16ce5409884eebbeec19c1806634da6ec66fbfbb476987a6437c29.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 149, + 82, + 464, + 138.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 149, + 138.66666666666666, + 464, + 195.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 149, + 195.33333333333331, + 464, + 251.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 174, + 263, + 435, + 275 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 176, + 263, + 435, + 276 + ], + "spans": [ + { + "bbox": [ + 176, + 263, + 435, + 276 + ], + "score": 1.0, + "content": "Figure 4: Fitting a regression model with out of distribution data", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "title", + "bbox": [ + 106, + 295, + 504, + 322 + ], + "lines": [ + { + "bbox": [ + 107, + 295, + 504, + 308 + ], + "spans": [ + { + "bbox": [ + 107, + 296, + 118, + 308 + ], + "score": 1.0, + "content": "A", + "type": "text" + }, + { + "bbox": [ + 127, + 295, + 504, + 308 + ], + "score": 1.0, + "content": "TOY EXAMPLE TO DEMONSTRATE BOUNDING THE VALUE OF THE OUT OF", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 128, + 311, + 371, + 321 + ], + "spans": [ + { + "bbox": [ + 128, + 311, + 371, + 321 + ], + "score": 1.0, + "content": "DISTRIBUTION INPUTS VIA GRADIENT PENALTY", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 106, + 334, + 505, + 447 + ], + "lines": [ + { + "bbox": [ + 106, + 334, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 106, + 334, + 505, + 347 + ], + "score": 1.0, + "content": "To demonstrate the effectiveness of the gradient penalty to enforce the bound of the predicted values", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 345, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 106, + 345, + 506, + 358 + ], + "score": 1.0, + "content": "of a regression model, we conduct experiments by fitting a regression model with in-distribution data", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 356, + 506, + 369 + ], + "spans": [ + { + "bbox": [ + 106, + 356, + 506, + 369 + ], + "score": 1.0, + "content": "while minimizing the norm of the gradient at out of distribution inputs. Specifically, we generate", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 103, + 362, + 508, + 384 + ], + "spans": [ + { + "bbox": [ + 103, + 362, + 138, + 384 + ], + "score": 1.0, + "content": "dataset", + "type": "text" + }, + { + "bbox": [ + 138, + 368, + 203, + 380 + ], + "score": 0.93, + "content": "\\{ ( x _ { i } , y _ { i } ) \\} _ { i = 1 } ^ { N = 1 0 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 204, + 362, + 218, + 384 + ], + "score": 1.0, + "content": "as", + "type": "text" + }, + { + "bbox": [ + 218, + 369, + 297, + 380 + ], + "score": 0.86, + "content": "x _ { i } \\sim U ( - 0 . 8 , 0 . 8 )", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 362, + 302, + 384 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 302, + 369, + 390, + 381 + ], + "score": 0.9, + "content": "\\begin{array} { r } { y _ { i } = 5 \\sin ( \\frac { \\pi } { 2 } x _ { i } ) + \\epsilon _ { i } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 391, + 362, + 424, + 384 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 424, + 369, + 487, + 380 + ], + "score": 0.92, + "content": "\\epsilon _ { i } \\sim \\mathcal { N } ( 0 , 0 . 5 )", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 362, + 508, + 384 + ], + "score": 1.0, + "content": ". In", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 102, + 374, + 509, + 403 + ], + "spans": [ + { + "bbox": [ + 102, + 374, + 198, + 403 + ], + "score": 1.0, + "content": "addition, we generate", + "type": "text" + }, + { + "bbox": [ + 205, + 374, + 303, + 403 + ], + "score": 1.0, + "content": "t of distribution dataset", + "type": "text" + }, + { + "bbox": [ + 303, + 381, + 345, + 394 + ], + "score": 0.9, + "content": "\\{ \\tilde { x } \\} _ { j = 1 } ^ { M = 1 0 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 346, + 374, + 359, + 403 + ], + "score": 1.0, + "content": "as", + "type": "text" + }, + { + "bbox": [ + 360, + 382, + 483, + 393 + ], + "score": 0.9, + "content": "\\tilde { x } \\sim U ( - 2 , - 0 . 8 ) \\cup U ( 0 . 8 , 2 )", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 374, + 509, + 403 + ], + "score": 1.0, + "content": ". We", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 198, + 394, + 204, + 403 + ], + "spans": [ + { + "bbox": [ + 198, + 394, + 204, + 403 + ], + "score": 0.87, + "content": "f", + "type": "inline_equation" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 402, + 504, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 504, + 414 + ], + "score": 1.0, + "content": "hidden layer is 64 and the activation is RELU. We use Adam (Kingma & Ba, 2015) optimizer with", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 413, + 505, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 505, + 426 + ], + "score": 1.0, + "content": "learning rate 0.01. In addition to the standard MSE loss, we add a gradient penalty term inspired", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 423, + 506, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 506, + 436 + ], + "score": 1.0, + "content": "from (Gulrajani et al., 2017) such that the gradient at the out of distribution inputs is penalized. The", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 434, + 203, + 447 + ], + "spans": [ + { + "bbox": [ + 106, + 434, + 203, + 447 + ], + "score": 1.0, + "content": "overall loss function is:", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 10.5 + }, + { + "type": "interline_equation", + "bbox": [ + 199, + 451, + 412, + 486 + ], + "lines": [ + { + "bbox": [ + 199, + 451, + 412, + 486 + ], + "spans": [ + { + "bbox": [ + 199, + 451, + 412, + 486 + ], + "score": 0.94, + "content": "\\mathcal { L } = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } ( f ( x _ { i } ) - y _ { i } ) ^ { 2 } + \\lambda \\cdot \\frac { 1 } { M } \\sum _ { j = 1 } ^ { M } | | \\nabla _ { \\tilde { x } } f ( \\tilde { x } _ { j } ) | | _ { 2 }", + "type": "interline_equation", + "image_path": "48cbbdcb118af8b75203fe4cd475a4b1870dfc365db205202792cd718cefb1e5.jpg" + } + ] + } + ], + "index": 16.5, + "virtual_lines": [ + { + "bbox": [ + 199, + 451, + 412, + 468.5 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 199, + 468.5, + 412, + 486.0 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 491, + 505, + 591 + ], + "lines": [ + { + "bbox": [ + 105, + 491, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 491, + 216, + 504 + ], + "score": 1.0, + "content": "In our experiments, we set", + "type": "text" + }, + { + "bbox": [ + 216, + 494, + 249, + 502 + ], + "score": 0.89, + "content": "\\lambda = 0 . 1", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 491, + 282, + 504 + ], + "score": 1.0, + "content": ". We fit", + "type": "text" + }, + { + "bbox": [ + 283, + 494, + 289, + 504 + ], + "score": 0.88, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 491, + 505, + 504 + ], + "score": 1.0, + "content": "with and without the gradient penalty term. Figure 4", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "score": 1.0, + "content": "shows the predicted value at both in-distribution and out-of-distribution inputs. The results suggest", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 514, + 504, + 525 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 399, + 525 + ], + "score": 1.0, + "content": "that: 1) both models generate good prediction for in-distribution inputs", + "type": "text" + }, + { + "bbox": [ + 399, + 515, + 447, + 525 + ], + "score": 0.73, + "content": "( [ - 0 . 8 , 0 . 8 ] )", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 514, + 504, + 525 + ], + "score": 1.0, + "content": ", which is be-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 523, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 505, + 538 + ], + "score": 1.0, + "content": "tween the two red lines 2) both models generalize well at the out-of-distribution regions between", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 535, + 504, + 547 + ], + "spans": [ + { + "bbox": [ + 106, + 535, + 228, + 547 + ], + "score": 1.0, + "content": "the red line and the blue line", + "type": "text" + }, + { + "bbox": [ + 228, + 537, + 274, + 547 + ], + "score": 0.9, + "content": "( [ - 1 , - 0 . 8 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 274, + 535, + 504, + 547 + ], + "score": 1.0, + "content": "and [0.8, 1]). 3) both models erroneously generalize be-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 545, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 105, + 545, + 187, + 559 + ], + "score": 1.0, + "content": "yond the blue lines", + "type": "text" + }, + { + "bbox": [ + 187, + 549, + 225, + 559 + ], + "score": 0.9, + "content": "( \\lfloor - 2 , - 1 \\rfloor", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 545, + 244, + 559 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 245, + 549, + 264, + 559 + ], + "score": 0.54, + "content": "\\lfloor 1 , 2 \\rfloor", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 545, + 505, + 559 + ], + "score": 1.0, + "content": "). However, the value of the model trained without gradient", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 557, + 505, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 557, + 505, + 570 + ], + "score": 1.0, + "content": "penalty keep on increasing or decreasing while the model trained with gradient penalty has zero", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 568, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 506, + 581 + ], + "score": 1.0, + "content": "gradient. This suggests that with proper out-of-distribution regularization, the gradient direction at", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 578, + 365, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 365, + 592 + ], + "score": 1.0, + "content": "the out-of-distribution inputs point to the in-distribution regions.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 22 + }, + { + "type": "title", + "bbox": [ + 109, + 608, + 498, + 620 + ], + "lines": [ + { + "bbox": [ + 108, + 608, + 500, + 620 + ], + "spans": [ + { + "bbox": [ + 108, + 608, + 117, + 619 + ], + "score": 1.0, + "content": "B", + "type": "text" + }, + { + "bbox": [ + 126, + 608, + 500, + 620 + ], + "score": 1.0, + "content": "VISUALIZATION OF VARIOUS PROBABILITY DIVERGENCE MEASUREMENT", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 106, + 632, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 632, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 106, + 632, + 279, + 645 + ], + "score": 1.0, + "content": "To understand the impact of forward KL", + "type": "text" + }, + { + "bbox": [ + 279, + 635, + 333, + 645 + ], + "score": 0.89, + "content": "( \\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { \\theta } | | \\pi _ { b } ) ) ", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 632, + 401, + 645 + ], + "score": 1.0, + "content": "), backward KL", + "type": "text" + }, + { + "bbox": [ + 402, + 635, + 456, + 645 + ], + "score": 0.89, + "content": "\\left( \\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { b } | | \\pi _ { \\theta } ) \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 632, + 505, + 645 + ], + "score": 1.0, + "content": ") and MMD", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 642, + 505, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 642, + 505, + 657 + ], + "score": 1.0, + "content": "distance in constraining the learned policy within the support set defined by the behavior policy,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 654, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 654, + 505, + 667 + ], + "score": 1.0, + "content": "we create a toy example as shown in Figure 5. The black curves in the two figures represent the", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 665, + 504, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 665, + 191, + 678 + ], + "score": 1.0, + "content": "behavior distribution", + "type": "text" + }, + { + "bbox": [ + 191, + 669, + 201, + 677 + ], + "score": 0.74, + "content": "\\pi _ { b }", + "type": "inline_equation" + }, + { + "bbox": [ + 202, + 665, + 504, + 678 + ], + "score": 1.0, + "content": ". The orange, blue and green curves in the graph show forward KL, backward", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 676, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 676, + 299, + 689 + ], + "score": 1.0, + "content": "KL and MMD with Laplacian kernel between", + "type": "text" + }, + { + "bbox": [ + 299, + 682, + 309, + 688 + ], + "score": 0.87, + "content": "\\boldsymbol { \\mathit { 1 0 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 676, + 330, + 689 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 331, + 678, + 392, + 689 + ], + "score": 0.94, + "content": "\\pi _ { \\theta } ~ = ~ \\mathcal { N } ( x , \\sigma )", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 676, + 479, + 689 + ], + "score": 1.0, + "content": ", respectively, where", + "type": "text" + }, + { + "bbox": [ + 479, + 680, + 486, + 687 + ], + "score": 0.72, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 676, + 506, + 689 + ], + "score": 1.0, + "content": "is a", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 178, + 699 + ], + "score": 1.0, + "content": "variable between", + "type": "text" + }, + { + "bbox": [ + 179, + 689, + 217, + 700 + ], + "score": 0.87, + "content": "[ - 1 0 , 1 0 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 687, + 237, + 699 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 237, + 693, + 244, + 698 + ], + "score": 0.89, + "content": "\\sigma", + "type": "inline_equation" + }, + { + "bbox": [ + 244, + 687, + 505, + 699 + ], + "score": 1.0, + "content": "is fixed. If we draw a horizontal line (red), the area below this", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 697, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 506, + 711 + ], + "score": 1.0, + "content": "line defines the support set. In the left figure, the behavior policy is single-modal and there is", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 708, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 722 + ], + "score": 1.0, + "content": "little difference between the three metrics. However, when the behavior policy is multi-modal, the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 719, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 719, + 506, + 733 + ], + "score": 1.0, + "content": "forward KL divergence contains two bottoms, each corresponds to the peak probability density of", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 32 + } + ], + "page_idx": 12, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 306, + 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 2021", + "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": "13", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 149, + 82, + 464, + 252 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 149, + 82, + 464, + 252 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 149, + 82, + 464, + 252 + ], + "spans": [ + { + "bbox": [ + 149, + 82, + 464, + 252 + ], + "score": 0.97, + "type": "image", + "image_path": "a1c91ac49d16ce5409884eebbeec19c1806634da6ec66fbfbb476987a6437c29.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 149, + 82, + 464, + 138.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 149, + 138.66666666666666, + 464, + 195.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 149, + 195.33333333333331, + 464, + 251.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 174, + 263, + 435, + 275 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 176, + 263, + 435, + 276 + ], + "spans": [ + { + "bbox": [ + 176, + 263, + 435, + 276 + ], + "score": 1.0, + "content": "Figure 4: Fitting a regression model with out of distribution data", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "title", + "bbox": [ + 106, + 295, + 504, + 322 + ], + "lines": [ + { + "bbox": [ + 107, + 295, + 504, + 308 + ], + "spans": [ + { + "bbox": [ + 107, + 296, + 118, + 308 + ], + "score": 1.0, + "content": "A", + "type": "text" + }, + { + "bbox": [ + 127, + 295, + 504, + 308 + ], + "score": 1.0, + "content": "TOY EXAMPLE TO DEMONSTRATE BOUNDING THE VALUE OF THE OUT OF", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 128, + 311, + 371, + 321 + ], + "spans": [ + { + "bbox": [ + 128, + 311, + 371, + 321 + ], + "score": 1.0, + "content": "DISTRIBUTION INPUTS VIA GRADIENT PENALTY", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "list", + "bbox": [ + 106, + 334, + 505, + 447 + ], + "lines": [ + { + "bbox": [ + 106, + 334, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 106, + 334, + 505, + 347 + ], + "score": 1.0, + "content": "To demonstrate the effectiveness of the gradient penalty to enforce the bound of the predicted values", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 345, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 106, + 345, + 506, + 358 + ], + "score": 1.0, + "content": "of a regression model, we conduct experiments by fitting a regression model with in-distribution data", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 356, + 506, + 369 + ], + "spans": [ + { + "bbox": [ + 106, + 356, + 506, + 369 + ], + "score": 1.0, + "content": "while minimizing the norm of the gradient at out of distribution inputs. Specifically, we generate", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 103, + 362, + 508, + 384 + ], + "spans": [ + { + "bbox": [ + 103, + 362, + 138, + 384 + ], + "score": 1.0, + "content": "dataset", + "type": "text" + }, + { + "bbox": [ + 138, + 368, + 203, + 380 + ], + "score": 0.93, + "content": "\\{ ( x _ { i } , y _ { i } ) \\} _ { i = 1 } ^ { N = 1 0 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 204, + 362, + 218, + 384 + ], + "score": 1.0, + "content": "as", + "type": "text" + }, + { + "bbox": [ + 218, + 369, + 297, + 380 + ], + "score": 0.86, + "content": "x _ { i } \\sim U ( - 0 . 8 , 0 . 8 )", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 362, + 302, + 384 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 302, + 369, + 390, + 381 + ], + "score": 0.9, + "content": "\\begin{array} { r } { y _ { i } = 5 \\sin ( \\frac { \\pi } { 2 } x _ { i } ) + \\epsilon _ { i } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 391, + 362, + 424, + 384 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 424, + 369, + 487, + 380 + ], + "score": 0.92, + "content": "\\epsilon _ { i } \\sim \\mathcal { N } ( 0 , 0 . 5 )", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 362, + 508, + 384 + ], + "score": 1.0, + "content": ". In", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 102, + 374, + 509, + 403 + ], + "spans": [ + { + "bbox": [ + 102, + 374, + 198, + 403 + ], + "score": 1.0, + "content": "addition, we generate", + "type": "text" + }, + { + "bbox": [ + 205, + 374, + 303, + 403 + ], + "score": 1.0, + "content": "t of distribution dataset", + "type": "text" + }, + { + "bbox": [ + 303, + 381, + 345, + 394 + ], + "score": 0.9, + "content": "\\{ \\tilde { x } \\} _ { j = 1 } ^ { M = 1 0 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 346, + 374, + 359, + 403 + ], + "score": 1.0, + "content": "as", + "type": "text" + }, + { + "bbox": [ + 360, + 382, + 483, + 393 + ], + "score": 0.9, + "content": "\\tilde { x } \\sim U ( - 2 , - 0 . 8 ) \\cup U ( 0 . 8 , 2 )", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 374, + 509, + 403 + ], + "score": 1.0, + "content": ". We", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 198, + 394, + 204, + 403 + ], + "spans": [ + { + "bbox": [ + 198, + 394, + 204, + 403 + ], + "score": 0.87, + "content": "f", + "type": "inline_equation" + } + ], + "index": 11, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 402, + 504, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 504, + 414 + ], + "score": 1.0, + "content": "hidden layer is 64 and the activation is RELU. We use Adam (Kingma & Ba, 2015) optimizer with", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 106, + 413, + 505, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 505, + 426 + ], + "score": 1.0, + "content": "learning rate 0.01. In addition to the standard MSE loss, we add a gradient penalty term inspired", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 423, + 506, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 506, + 436 + ], + "score": 1.0, + "content": "from (Gulrajani et al., 2017) such that the gradient at the out of distribution inputs is penalized. The", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 434, + 203, + 447 + ], + "spans": [ + { + "bbox": [ + 106, + 434, + 203, + 447 + ], + "score": 1.0, + "content": "overall loss function is:", + "type": "text" + } + ], + "index": 15, + "is_list_end_line": true + } + ], + "index": 10.5, + "bbox_fs": [ + 102, + 334, + 509, + 447 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 199, + 451, + 412, + 486 + ], + "lines": [ + { + "bbox": [ + 199, + 451, + 412, + 486 + ], + "spans": [ + { + "bbox": [ + 199, + 451, + 412, + 486 + ], + "score": 0.94, + "content": "\\mathcal { L } = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } ( f ( x _ { i } ) - y _ { i } ) ^ { 2 } + \\lambda \\cdot \\frac { 1 } { M } \\sum _ { j = 1 } ^ { M } | | \\nabla _ { \\tilde { x } } f ( \\tilde { x } _ { j } ) | | _ { 2 }", + "type": "interline_equation", + "image_path": "48cbbdcb118af8b75203fe4cd475a4b1870dfc365db205202792cd718cefb1e5.jpg" + } + ] + } + ], + "index": 16.5, + "virtual_lines": [ + { + "bbox": [ + 199, + 451, + 412, + 468.5 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 199, + 468.5, + 412, + 486.0 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 491, + 505, + 591 + ], + "lines": [ + { + "bbox": [ + 105, + 491, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 491, + 216, + 504 + ], + "score": 1.0, + "content": "In our experiments, we set", + "type": "text" + }, + { + "bbox": [ + 216, + 494, + 249, + 502 + ], + "score": 0.89, + "content": "\\lambda = 0 . 1", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 491, + 282, + 504 + ], + "score": 1.0, + "content": ". We fit", + "type": "text" + }, + { + "bbox": [ + 283, + 494, + 289, + 504 + ], + "score": 0.88, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 491, + 505, + 504 + ], + "score": 1.0, + "content": "with and without the gradient penalty term. Figure 4", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "score": 1.0, + "content": "shows the predicted value at both in-distribution and out-of-distribution inputs. The results suggest", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 514, + 504, + 525 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 399, + 525 + ], + "score": 1.0, + "content": "that: 1) both models generate good prediction for in-distribution inputs", + "type": "text" + }, + { + "bbox": [ + 399, + 515, + 447, + 525 + ], + "score": 0.73, + "content": "( [ - 0 . 8 , 0 . 8 ] )", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 514, + 504, + 525 + ], + "score": 1.0, + "content": ", which is be-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 523, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 505, + 538 + ], + "score": 1.0, + "content": "tween the two red lines 2) both models generalize well at the out-of-distribution regions between", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 535, + 504, + 547 + ], + "spans": [ + { + "bbox": [ + 106, + 535, + 228, + 547 + ], + "score": 1.0, + "content": "the red line and the blue line", + "type": "text" + }, + { + "bbox": [ + 228, + 537, + 274, + 547 + ], + "score": 0.9, + "content": "( [ - 1 , - 0 . 8 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 274, + 535, + 504, + 547 + ], + "score": 1.0, + "content": "and [0.8, 1]). 3) both models erroneously generalize be-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 545, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 105, + 545, + 187, + 559 + ], + "score": 1.0, + "content": "yond the blue lines", + "type": "text" + }, + { + "bbox": [ + 187, + 549, + 225, + 559 + ], + "score": 0.9, + "content": "( \\lfloor - 2 , - 1 \\rfloor", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 545, + 244, + 559 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 245, + 549, + 264, + 559 + ], + "score": 0.54, + "content": "\\lfloor 1 , 2 \\rfloor", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 545, + 505, + 559 + ], + "score": 1.0, + "content": "). However, the value of the model trained without gradient", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 557, + 505, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 557, + 505, + 570 + ], + "score": 1.0, + "content": "penalty keep on increasing or decreasing while the model trained with gradient penalty has zero", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 568, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 506, + 581 + ], + "score": 1.0, + "content": "gradient. This suggests that with proper out-of-distribution regularization, the gradient direction at", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 578, + 365, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 365, + 592 + ], + "score": 1.0, + "content": "the out-of-distribution inputs point to the in-distribution regions.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 22, + "bbox_fs": [ + 105, + 491, + 506, + 592 + ] + }, + { + "type": "title", + "bbox": [ + 109, + 608, + 498, + 620 + ], + "lines": [ + { + "bbox": [ + 108, + 608, + 500, + 620 + ], + "spans": [ + { + "bbox": [ + 108, + 608, + 117, + 619 + ], + "score": 1.0, + "content": "B", + "type": "text" + }, + { + "bbox": [ + 126, + 608, + 500, + 620 + ], + "score": 1.0, + "content": "VISUALIZATION OF VARIOUS PROBABILITY DIVERGENCE MEASUREMENT", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 106, + 632, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 632, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 106, + 632, + 279, + 645 + ], + "score": 1.0, + "content": "To understand the impact of forward KL", + "type": "text" + }, + { + "bbox": [ + 279, + 635, + 333, + 645 + ], + "score": 0.89, + "content": "( \\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { \\theta } | | \\pi _ { b } ) ) ", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 632, + 401, + 645 + ], + "score": 1.0, + "content": "), backward KL", + "type": "text" + }, + { + "bbox": [ + 402, + 635, + 456, + 645 + ], + "score": 0.89, + "content": "\\left( \\mathcal { D } _ { \\mathrm { K L } } ( \\pi _ { b } | | \\pi _ { \\theta } ) \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 632, + 505, + 645 + ], + "score": 1.0, + "content": ") and MMD", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 642, + 505, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 642, + 505, + 657 + ], + "score": 1.0, + "content": "distance in constraining the learned policy within the support set defined by the behavior policy,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 654, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 654, + 505, + 667 + ], + "score": 1.0, + "content": "we create a toy example as shown in Figure 5. The black curves in the two figures represent the", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 665, + 504, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 665, + 191, + 678 + ], + "score": 1.0, + "content": "behavior distribution", + "type": "text" + }, + { + "bbox": [ + 191, + 669, + 201, + 677 + ], + "score": 0.74, + "content": "\\pi _ { b }", + "type": "inline_equation" + }, + { + "bbox": [ + 202, + 665, + 504, + 678 + ], + "score": 1.0, + "content": ". The orange, blue and green curves in the graph show forward KL, backward", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 676, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 676, + 299, + 689 + ], + "score": 1.0, + "content": "KL and MMD with Laplacian kernel between", + "type": "text" + }, + { + "bbox": [ + 299, + 682, + 309, + 688 + ], + "score": 0.87, + "content": "\\boldsymbol { \\mathit { 1 0 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 676, + 330, + 689 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 331, + 678, + 392, + 689 + ], + "score": 0.94, + "content": "\\pi _ { \\theta } ~ = ~ \\mathcal { N } ( x , \\sigma )", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 676, + 479, + 689 + ], + "score": 1.0, + "content": ", respectively, where", + "type": "text" + }, + { + "bbox": [ + 479, + 680, + 486, + 687 + ], + "score": 0.72, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 676, + 506, + 689 + ], + "score": 1.0, + "content": "is a", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 178, + 699 + ], + "score": 1.0, + "content": "variable between", + "type": "text" + }, + { + "bbox": [ + 179, + 689, + 217, + 700 + ], + "score": 0.87, + "content": "[ - 1 0 , 1 0 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 687, + 237, + 699 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 237, + 693, + 244, + 698 + ], + "score": 0.89, + "content": "\\sigma", + "type": "inline_equation" + }, + { + "bbox": [ + 244, + 687, + 505, + 699 + ], + "score": 1.0, + "content": "is fixed. If we draw a horizontal line (red), the area below this", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 697, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 506, + 711 + ], + "score": 1.0, + "content": "line defines the support set. In the left figure, the behavior policy is single-modal and there is", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 708, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 722 + ], + "score": 1.0, + "content": "little difference between the three metrics. However, when the behavior policy is multi-modal, the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 719, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 719, + 506, + 733 + ], + "score": 1.0, + "content": "forward KL divergence contains two bottoms, each corresponds to the peak probability density of", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 274, + 506, + 287 + ], + "spans": [ + { + "bbox": [ + 106, + 274, + 506, + 287 + ], + "score": 1.0, + "content": "the behavior policy. However, in backward KL and MMD distance, the policy with the smallest", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 284, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 506, + 299 + ], + "score": 1.0, + "content": "divergence actually has low probability density in the behavior policy. This is because minimizing", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 297, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 106, + 297, + 505, + 308 + ], + "score": 1.0, + "content": "the forward KL leads to “mode seeking” while minimizing the backward KL and MMD leads to", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 108, + 307, + 504, + 319 + ], + "spans": [ + { + "bbox": [ + 108, + 307, + 504, + 319 + ], + "score": 1.0, + "content": "“mode covering”. These two terms are heavily used when talking about generative models such", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 319, + 505, + 330 + ], + "spans": [ + { + "bbox": [ + 106, + 319, + 505, + 330 + ], + "score": 1.0, + "content": "as VAEs and GANs (Ke et al., 2019). When performing offline RL in multi-modal dataset, it is", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 329, + 504, + 342 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 504, + 342 + ], + "score": 1.0, + "content": "necessary to combine sub-optimal actions in the behavior policy, which is in fact “mode seeking”.", + "type": "text", + "cross_page": true + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 340, + 505, + 352 + ], + "spans": [ + { + "bbox": [ + 106, + 340, + 505, + 352 + ], + "score": 1.0, + "content": "Mode covering typically leads to out-of-distribution actions even when the divergence measurement", + "type": "text", + "cross_page": true + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 350, + 505, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 350, + 505, + 365 + ], + "score": 1.0, + "content": "is small (e.g. the area between the two modes are actually out-of-distribution) while mode seeking", + "type": "text", + "cross_page": true + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 363, + 427, + 374 + ], + "spans": [ + { + "bbox": [ + 106, + 363, + 427, + 374 + ], + "score": 1.0, + "content": "may be stuck at a local optimum (e.g. moving across different “modes” is hard).", + "type": "text", + "cross_page": true + } + ], + "index": 14 + } + ], + "index": 32, + "bbox_fs": [ + 105, + 632, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 147, + 87, + 465, + 207 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 147, + 87, + 465, + 207 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 147, + 87, + 465, + 207 + ], + "spans": [ + { + "bbox": [ + 147, + 87, + 465, + 207 + ], + "score": 0.972, + "type": "image", + "image_path": "5a639b65eb020709bafc3ba11100d983cd249ee7f76e31c22d118ec56717e901.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 147, + 87, + 465, + 127.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 147, + 127.0, + 465, + 167.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 147, + 167.0, + 465, + 207.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 217, + 505, + 251 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 216, + 505, + 231 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 437, + 231 + ], + "score": 1.0, + "content": "Figure 5: The black curve in the two figures represents the behavior distribution", + "type": "text" + }, + { + "bbox": [ + 437, + 219, + 447, + 228 + ], + "score": 0.85, + "content": "\\pi _ { b }", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 216, + 505, + 231 + ], + "score": 1.0, + "content": ". The orange,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 228, + 505, + 240 + ], + "spans": [ + { + "bbox": [ + 106, + 228, + 505, + 240 + ], + "score": 1.0, + "content": "blue and green curves in the graph show forward KL, backward KL and MMD with Laplacian kernel", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 239, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 106, + 239, + 142, + 252 + ], + "score": 1.0, + "content": "between", + "type": "text" + }, + { + "bbox": [ + 142, + 241, + 153, + 250 + ], + "score": 0.86, + "content": "\\pi _ { b }", + "type": "inline_equation" + }, + { + "bbox": [ + 154, + 239, + 171, + 252 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 171, + 239, + 229, + 251 + ], + "score": 0.93, + "content": "\\pi _ { \\boldsymbol { \\theta } } = \\mathcal { N } ( \\boldsymbol { x } , \\bar { \\boldsymbol { \\sigma } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 229, + 239, + 311, + 252 + ], + "score": 1.0, + "content": ", respectively, where", + "type": "text" + }, + { + "bbox": [ + 312, + 241, + 319, + 249 + ], + "score": 0.78, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 319, + 239, + 406, + 252 + ], + "score": 1.0, + "content": "is a variable between", + "type": "text" + }, + { + "bbox": [ + 406, + 239, + 444, + 251 + ], + "score": 0.84, + "content": "[ - 1 0 , 1 0 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 239, + 462, + 252 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 463, + 241, + 470, + 249 + ], + "score": 0.78, + "content": "\\sigma", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 239, + 505, + 252 + ], + "score": 1.0, + "content": "is fixed.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 106, + 274, + 505, + 374 + ], + "lines": [ + { + "bbox": [ + 106, + 274, + 506, + 287 + ], + "spans": [ + { + "bbox": [ + 106, + 274, + 506, + 287 + ], + "score": 1.0, + "content": "the behavior policy. However, in backward KL and MMD distance, the policy with the smallest", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 284, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 506, + 299 + ], + "score": 1.0, + "content": "divergence actually has low probability density in the behavior policy. This is because minimizing", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 297, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 106, + 297, + 505, + 308 + ], + "score": 1.0, + "content": "the forward KL leads to “mode seeking” while minimizing the backward KL and MMD leads to", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 108, + 307, + 504, + 319 + ], + "spans": [ + { + "bbox": [ + 108, + 307, + 504, + 319 + ], + "score": 1.0, + "content": "“mode covering”. These two terms are heavily used when talking about generative models such", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 319, + 505, + 330 + ], + "spans": [ + { + "bbox": [ + 106, + 319, + 505, + 330 + ], + "score": 1.0, + "content": "as VAEs and GANs (Ke et al., 2019). When performing offline RL in multi-modal dataset, it is", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 329, + 504, + 342 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 504, + 342 + ], + "score": 1.0, + "content": "necessary to combine sub-optimal actions in the behavior policy, which is in fact “mode seeking”.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 340, + 505, + 352 + ], + "spans": [ + { + "bbox": [ + 106, + 340, + 505, + 352 + ], + "score": 1.0, + "content": "Mode covering typically leads to out-of-distribution actions even when the divergence measurement", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 350, + 505, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 350, + 505, + 365 + ], + "score": 1.0, + "content": "is small (e.g. the area between the two modes are actually out-of-distribution) while mode seeking", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 363, + 427, + 374 + ], + "spans": [ + { + "bbox": [ + 106, + 363, + 427, + 374 + ], + "score": 1.0, + "content": "may be stuck at a local optimum (e.g. moving across different “modes” is hard).", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 379, + 503, + 412 + ], + "lines": [ + { + "bbox": [ + 105, + 378, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 178, + 392 + ], + "score": 1.0, + "content": "In the left figure,", + "type": "text" + }, + { + "bbox": [ + 178, + 381, + 235, + 392 + ], + "score": 0.91, + "content": "\\pi _ { b } = \\mathcal { N } ( 0 , 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 378, + 318, + 392 + ], + "score": 1.0, + "content": ". In the right figure,", + "type": "text" + }, + { + "bbox": [ + 318, + 381, + 329, + 391 + ], + "score": 0.77, + "content": "\\pi _ { b }", + "type": "inline_equation" + }, + { + "bbox": [ + 329, + 378, + 505, + 392 + ], + "score": 1.0, + "content": "is a mixture of two Gaussian distributions:", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 107, + 389, + 505, + 402 + ], + "spans": [ + { + "bbox": [ + 107, + 392, + 162, + 402 + ], + "score": 0.9, + "content": "\\mathcal { N } ( - 1 . 5 , 0 . 3 )", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 389, + 181, + 402 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 181, + 392, + 221, + 402 + ], + "score": 0.9, + "content": "\\mathcal { N } ( 1 , 0 . 5 )", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 389, + 464, + 402 + ], + "score": 1.0, + "content": ". The weight of each component is 0.3 and 0.7, respectively.", + "type": "text" + }, + { + "bbox": [ + 464, + 395, + 470, + 400 + ], + "score": 0.77, + "content": "\\sigma", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 389, + 505, + 402 + ], + "score": 1.0, + "content": "is set to", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 399, + 125, + 414 + ], + "spans": [ + { + "bbox": [ + 104, + 399, + 125, + 414 + ], + "score": 1.0, + "content": "0.2.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16 + }, + { + "type": "title", + "bbox": [ + 108, + 431, + 251, + 444 + ], + "lines": [ + { + "bbox": [ + 106, + 430, + 252, + 446 + ], + "spans": [ + { + "bbox": [ + 106, + 430, + 252, + 446 + ], + "score": 1.0, + "content": "C MISSING BACKGROUND", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "title", + "bbox": [ + 108, + 457, + 265, + 469 + ], + "lines": [ + { + "bbox": [ + 106, + 457, + 267, + 470 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 267, + 470 + ], + "score": 1.0, + "content": "C.1 VARIATIONAL AUTO-ENCODER", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 108, + 479, + 504, + 513 + ], + "lines": [ + { + "bbox": [ + 106, + 479, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 505, + 492 + ], + "score": 1.0, + "content": "A variational auto-encoder (VAE) (Kingma & Welling, 2014) is a generative model that aims to learn", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 102, + 485, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 102, + 485, + 190, + 509 + ], + "score": 1.0, + "content": "the data distribution", + "type": "text" + }, + { + "bbox": [ + 190, + 491, + 213, + 503 + ], + "score": 0.92, + "content": "p ( X )", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 485, + 325, + 509 + ], + "score": 1.0, + "content": "given a set of observations", + "type": "text" + }, + { + "bbox": [ + 325, + 490, + 358, + 503 + ], + "score": 0.93, + "content": "\\{ x _ { i } \\} _ { i = 1 } ^ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 359, + 485, + 471, + 509 + ], + "score": 1.0, + "content": ". While directly optimizing", + "type": "text" + }, + { + "bbox": [ + 471, + 491, + 494, + 503 + ], + "score": 0.92, + "content": "p ( X )", + "type": "inline_equation" + }, + { + "bbox": [ + 494, + 485, + 505, + 509 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 502, + 362, + 514 + ], + "spans": [ + { + "bbox": [ + 106, + 502, + 362, + 514 + ], + "score": 1.0, + "content": "intractable, we can optimize its evidence lower-bound (ELBO):", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21 + }, + { + "type": "interline_equation", + "bbox": [ + 199, + 520, + 411, + 536 + ], + "lines": [ + { + "bbox": [ + 199, + 520, + 411, + 536 + ], + "spans": [ + { + "bbox": [ + 199, + 520, + 411, + 536 + ], + "score": 0.89, + "content": "\\begin{array} { r } { \\log p ( X ) \\ge \\mathbb { E } _ { z \\sim q ( z ) } [ \\log p ( X | z ) ] - \\mathcal { D } _ { \\mathrm { K L } } ( q ( z ) | | p ( z ) ) } \\end{array}", + "type": "interline_equation", + "image_path": "bc204ebf117900e818505662b26896a4cd24553abc728482a6d2c64c5c029cad.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 199, + 520, + 411, + 536 + ], + "spans": [], + "index": 23 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 542, + 505, + 599 + ], + "lines": [ + { + "bbox": [ + 105, + 543, + 506, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 134, + 556 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 543, + 155, + 555 + ], + "score": 0.92, + "content": "q ( Z )", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 543, + 295, + 556 + ], + "score": 1.0, + "content": "is the variational distribution and", + "type": "text" + }, + { + "bbox": [ + 295, + 543, + 316, + 555 + ], + "score": 0.92, + "content": "p ( Z )", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 543, + 407, + 556 + ], + "score": 1.0, + "content": "is the prior. In VAE,", + "type": "text" + }, + { + "bbox": [ + 407, + 543, + 428, + 555 + ], + "score": 0.92, + "content": "q ( Z )", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 543, + 440, + 556 + ], + "score": 1.0, + "content": "is", + "type": "text" + }, + { + "bbox": [ + 441, + 543, + 473, + 555 + ], + "score": 0.94, + "content": "q ( Z | X )", + "type": "inline_equation" + }, + { + "bbox": [ + 474, + 543, + 506, + 556 + ], + "score": 1.0, + "content": "so that", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 104, + 553, + 505, + 567 + ], + "spans": [ + { + "bbox": [ + 104, + 553, + 505, + 567 + ], + "score": 1.0, + "content": "it is an auto-encoder. Optimizing Equation 12 using gradient descent requires back-propagate the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 565, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 505, + 578 + ], + "score": 1.0, + "content": "gradient through a sample operator. Fortunately, if the latent variable is a multivariate Gaussian dis-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 574, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 505, + 590 + ], + "score": 1.0, + "content": "tribution, we can use re-parametrization trick. The tightness of the upper bound is the KL divergence", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 587, + 438, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 438, + 600 + ], + "score": 1.0, + "content": "between the approximated posterior distribution and the true posterior distribution.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26 + }, + { + "type": "title", + "bbox": [ + 108, + 617, + 270, + 630 + ], + "lines": [ + { + "bbox": [ + 105, + 616, + 271, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 271, + 630 + ], + "score": 1.0, + "content": "D MISSING ABLATION STUDY", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 643, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 643, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 643, + 505, + 656 + ], + "score": 1.0, + "content": "For fair comparison between MMD and KL divergence in policy regularization, we only substitute", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 654, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 654, + 505, + 667 + ], + "score": 1.0, + "content": "KL divergence with MMD-based measurement with additional MMD-specific hyperparameter tun-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 666, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 677 + ], + "score": 1.0, + "content": "ing. In the original implementation (Kumar et al., 2019), the author uses 4 ensembles of Q network", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 677, + 505, + 688 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 688 + ], + "score": 1.0, + "content": "and compute the Q value by a convex combination of both the minimum of the ensembles and the", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "score": 1.0, + "content": "maximum of the ensembles. In our implementation, we follow the standard architecture in the online", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 699, + 505, + 710 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 710 + ], + "score": 1.0, + "content": "setting: we only use 2 ensembles of Q networks and compute the Q value as their minimum. In this", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "work, we only compare against MMD with Laplacian kernels. The MMD-specific hyper-parameters", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 721, + 194, + 731 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 194, + 731 + ], + "score": 1.0, + "content": "are shown in Table 3.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 33.5 + } + ], + "page_idx": 13, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "14", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 306, + 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 2021", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 147, + 87, + 465, + 207 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 147, + 87, + 465, + 207 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 147, + 87, + 465, + 207 + ], + "spans": [ + { + "bbox": [ + 147, + 87, + 465, + 207 + ], + "score": 0.972, + "type": "image", + "image_path": "5a639b65eb020709bafc3ba11100d983cd249ee7f76e31c22d118ec56717e901.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 147, + 87, + 465, + 127.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 147, + 127.0, + 465, + 167.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 147, + 167.0, + 465, + 207.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 217, + 505, + 251 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 216, + 505, + 231 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 437, + 231 + ], + "score": 1.0, + "content": "Figure 5: The black curve in the two figures represents the behavior distribution", + "type": "text" + }, + { + "bbox": [ + 437, + 219, + 447, + 228 + ], + "score": 0.85, + "content": "\\pi _ { b }", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 216, + 505, + 231 + ], + "score": 1.0, + "content": ". The orange,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 228, + 505, + 240 + ], + "spans": [ + { + "bbox": [ + 106, + 228, + 505, + 240 + ], + "score": 1.0, + "content": "blue and green curves in the graph show forward KL, backward KL and MMD with Laplacian kernel", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 239, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 106, + 239, + 142, + 252 + ], + "score": 1.0, + "content": "between", + "type": "text" + }, + { + "bbox": [ + 142, + 241, + 153, + 250 + ], + "score": 0.86, + "content": "\\pi _ { b }", + "type": "inline_equation" + }, + { + "bbox": [ + 154, + 239, + 171, + 252 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 171, + 239, + 229, + 251 + ], + "score": 0.93, + "content": "\\pi _ { \\boldsymbol { \\theta } } = \\mathcal { N } ( \\boldsymbol { x } , \\bar { \\boldsymbol { \\sigma } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 229, + 239, + 311, + 252 + ], + "score": 1.0, + "content": ", respectively, where", + "type": "text" + }, + { + "bbox": [ + 312, + 241, + 319, + 249 + ], + "score": 0.78, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 319, + 239, + 406, + 252 + ], + "score": 1.0, + "content": "is a variable between", + "type": "text" + }, + { + "bbox": [ + 406, + 239, + 444, + 251 + ], + "score": 0.84, + "content": "[ - 1 0 , 1 0 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 239, + 462, + 252 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 463, + 241, + 470, + 249 + ], + "score": 0.78, + "content": "\\sigma", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 239, + 505, + 252 + ], + "score": 1.0, + "content": "is fixed.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 106, + 274, + 505, + 374 + ], + "lines": [], + "index": 10, + "bbox_fs": [ + 105, + 274, + 506, + 374 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 379, + 503, + 412 + ], + "lines": [ + { + "bbox": [ + 105, + 378, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 178, + 392 + ], + "score": 1.0, + "content": "In the left figure,", + "type": "text" + }, + { + "bbox": [ + 178, + 381, + 235, + 392 + ], + "score": 0.91, + "content": "\\pi _ { b } = \\mathcal { N } ( 0 , 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 378, + 318, + 392 + ], + "score": 1.0, + "content": ". In the right figure,", + "type": "text" + }, + { + "bbox": [ + 318, + 381, + 329, + 391 + ], + "score": 0.77, + "content": "\\pi _ { b }", + "type": "inline_equation" + }, + { + "bbox": [ + 329, + 378, + 505, + 392 + ], + "score": 1.0, + "content": "is a mixture of two Gaussian distributions:", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 107, + 389, + 505, + 402 + ], + "spans": [ + { + "bbox": [ + 107, + 392, + 162, + 402 + ], + "score": 0.9, + "content": "\\mathcal { N } ( - 1 . 5 , 0 . 3 )", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 389, + 181, + 402 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 181, + 392, + 221, + 402 + ], + "score": 0.9, + "content": "\\mathcal { N } ( 1 , 0 . 5 )", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 389, + 464, + 402 + ], + "score": 1.0, + "content": ". The weight of each component is 0.3 and 0.7, respectively.", + "type": "text" + }, + { + "bbox": [ + 464, + 395, + 470, + 400 + ], + "score": 0.77, + "content": "\\sigma", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 389, + 505, + 402 + ], + "score": 1.0, + "content": "is set to", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 399, + 125, + 414 + ], + "spans": [ + { + "bbox": [ + 104, + 399, + 125, + 414 + ], + "score": 1.0, + "content": "0.2.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16, + "bbox_fs": [ + 104, + 378, + 505, + 414 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 431, + 251, + 444 + ], + "lines": [ + { + "bbox": [ + 106, + 430, + 252, + 446 + ], + "spans": [ + { + "bbox": [ + 106, + 430, + 252, + 446 + ], + "score": 1.0, + "content": "C MISSING BACKGROUND", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "title", + "bbox": [ + 108, + 457, + 265, + 469 + ], + "lines": [ + { + "bbox": [ + 106, + 457, + 267, + 470 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 267, + 470 + ], + "score": 1.0, + "content": "C.1 VARIATIONAL AUTO-ENCODER", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 108, + 479, + 504, + 513 + ], + "lines": [ + { + "bbox": [ + 106, + 479, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 505, + 492 + ], + "score": 1.0, + "content": "A variational auto-encoder (VAE) (Kingma & Welling, 2014) is a generative model that aims to learn", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 102, + 485, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 102, + 485, + 190, + 509 + ], + "score": 1.0, + "content": "the data distribution", + "type": "text" + }, + { + "bbox": [ + 190, + 491, + 213, + 503 + ], + "score": 0.92, + "content": "p ( X )", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 485, + 325, + 509 + ], + "score": 1.0, + "content": "given a set of observations", + "type": "text" + }, + { + "bbox": [ + 325, + 490, + 358, + 503 + ], + "score": 0.93, + "content": "\\{ x _ { i } \\} _ { i = 1 } ^ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 359, + 485, + 471, + 509 + ], + "score": 1.0, + "content": ". While directly optimizing", + "type": "text" + }, + { + "bbox": [ + 471, + 491, + 494, + 503 + ], + "score": 0.92, + "content": "p ( X )", + "type": "inline_equation" + }, + { + "bbox": [ + 494, + 485, + 505, + 509 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 502, + 362, + 514 + ], + "spans": [ + { + "bbox": [ + 106, + 502, + 362, + 514 + ], + "score": 1.0, + "content": "intractable, we can optimize its evidence lower-bound (ELBO):", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21, + "bbox_fs": [ + 102, + 479, + 505, + 514 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 199, + 520, + 411, + 536 + ], + "lines": [ + { + "bbox": [ + 199, + 520, + 411, + 536 + ], + "spans": [ + { + "bbox": [ + 199, + 520, + 411, + 536 + ], + "score": 0.89, + "content": "\\begin{array} { r } { \\log p ( X ) \\ge \\mathbb { E } _ { z \\sim q ( z ) } [ \\log p ( X | z ) ] - \\mathcal { D } _ { \\mathrm { K L } } ( q ( z ) | | p ( z ) ) } \\end{array}", + "type": "interline_equation", + "image_path": "bc204ebf117900e818505662b26896a4cd24553abc728482a6d2c64c5c029cad.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 199, + 520, + 411, + 536 + ], + "spans": [], + "index": 23 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 542, + 505, + 599 + ], + "lines": [ + { + "bbox": [ + 105, + 543, + 506, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 134, + 556 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 543, + 155, + 555 + ], + "score": 0.92, + "content": "q ( Z )", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 543, + 295, + 556 + ], + "score": 1.0, + "content": "is the variational distribution and", + "type": "text" + }, + { + "bbox": [ + 295, + 543, + 316, + 555 + ], + "score": 0.92, + "content": "p ( Z )", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 543, + 407, + 556 + ], + "score": 1.0, + "content": "is the prior. In VAE,", + "type": "text" + }, + { + "bbox": [ + 407, + 543, + 428, + 555 + ], + "score": 0.92, + "content": "q ( Z )", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 543, + 440, + 556 + ], + "score": 1.0, + "content": "is", + "type": "text" + }, + { + "bbox": [ + 441, + 543, + 473, + 555 + ], + "score": 0.94, + "content": "q ( Z | X )", + "type": "inline_equation" + }, + { + "bbox": [ + 474, + 543, + 506, + 556 + ], + "score": 1.0, + "content": "so that", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 104, + 553, + 505, + 567 + ], + "spans": [ + { + "bbox": [ + 104, + 553, + 505, + 567 + ], + "score": 1.0, + "content": "it is an auto-encoder. Optimizing Equation 12 using gradient descent requires back-propagate the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 565, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 505, + 578 + ], + "score": 1.0, + "content": "gradient through a sample operator. Fortunately, if the latent variable is a multivariate Gaussian dis-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 574, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 505, + 590 + ], + "score": 1.0, + "content": "tribution, we can use re-parametrization trick. The tightness of the upper bound is the KL divergence", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 587, + 438, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 438, + 600 + ], + "score": 1.0, + "content": "between the approximated posterior distribution and the true posterior distribution.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26, + "bbox_fs": [ + 104, + 543, + 506, + 600 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 617, + 270, + 630 + ], + "lines": [ + { + "bbox": [ + 105, + 616, + 271, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 271, + 630 + ], + "score": 1.0, + "content": "D MISSING ABLATION STUDY", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 643, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 643, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 643, + 505, + 656 + ], + "score": 1.0, + "content": "For fair comparison between MMD and KL divergence in policy regularization, we only substitute", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 654, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 654, + 505, + 667 + ], + "score": 1.0, + "content": "KL divergence with MMD-based measurement with additional MMD-specific hyperparameter tun-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 666, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 677 + ], + "score": 1.0, + "content": "ing. In the original implementation (Kumar et al., 2019), the author uses 4 ensembles of Q network", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 677, + 505, + 688 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 688 + ], + "score": 1.0, + "content": "and compute the Q value by a convex combination of both the minimum of the ensembles and the", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "score": 1.0, + "content": "maximum of the ensembles. In our implementation, we follow the standard architecture in the online", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 699, + 505, + 710 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 710 + ], + "score": 1.0, + "content": "setting: we only use 2 ensembles of Q networks and compute the Q value as their minimum. In this", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "work, we only compare against MMD with Laplacian kernels. The MMD-specific hyper-parameters", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 721, + 194, + 731 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 194, + 731 + ], + "score": 1.0, + "content": "are shown in Table 3.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 643, + 505, + 731 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 505, + 148 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 506, + 95 + ], + "score": 1.0, + "content": "Difference in training the behavior policy (Kumar et al., 2019) learns the behavior policy as", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 92, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 92, + 114, + 106 + ], + "score": 1.0, + "content": "a", + "type": "text" + }, + { + "bbox": [ + 115, + 94, + 122, + 105 + ], + "score": 0.83, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 122, + 92, + 505, + 106 + ], + "score": 1.0, + "content": "-VAE (Higgins et al., 2017) with MSE reconstruction loss. This is equivalent to maximizing", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "the log probability of a Gaussian distribution with fixed variance as the decoder output. However,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 290, + 127 + ], + "score": 1.0, + "content": "the variational lower bound does not hold in", + "type": "text" + }, + { + "bbox": [ + 291, + 116, + 298, + 127 + ], + "score": 0.83, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 299, + 114, + 505, + 127 + ], + "score": 1.0, + "content": "-VAE that breaks our derivation. In this paper, we", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 106, + 126, + 505, + 139 + ], + "score": 1.0, + "content": "learn the behavior policy as a regular VAE. The decoder outputs a Gaussian distribution with input-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 137, + 235, + 150 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 235, + 150 + ], + "score": 1.0, + "content": "conditioned mean and variance.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 165, + 505, + 198 + ], + "lines": [ + { + "bbox": [ + 105, + 164, + 506, + 177 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 506, + 177 + ], + "score": 1.0, + "content": "Gradient penalized policy evaluation Figure 6 suggests that the L2 norm of the gradient at the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 176, + 505, + 187 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 505, + 187 + ], + "score": 1.0, + "content": "out-of-distribution actions with the gradient penalty is much lower than that without the gradient", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 186, + 141, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 141, + 201 + ], + "score": 1.0, + "content": "penalty.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7 + }, + { + "type": "image", + "bbox": [ + 108, + 212, + 504, + 331 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 212, + 504, + 331 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 212, + 504, + 331 + ], + "spans": [ + { + "bbox": [ + 108, + 212, + 504, + 331 + ], + "score": 0.962, + "type": "image", + "image_path": "1e7b6a34bc8b6db03c161a6bd33f24a4fbe50c88de544e7755a5d07be157b435.jpg" + } + ] + } + ], + "index": 10, + "virtual_lines": [ + { + "bbox": [ + 108, + 212, + 504, + 251.66666666666666 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 108, + 251.66666666666666, + 504, + 291.3333333333333 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 108, + 291.3333333333333, + 504, + 331.0 + ], + "spans": [], + "index": 11 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 140, + 342, + 471, + 353 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 139, + 341, + 472, + 355 + ], + "spans": [ + { + "bbox": [ + 139, + 341, + 472, + 355 + ], + "score": 1.0, + "content": "Figure 6: Histogram of the L2 norm of the gradients for out-of-distribution actions", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + } + ], + "index": 11.0 + }, + { + "type": "text", + "bbox": [ + 106, + 385, + 505, + 484 + ], + "lines": [ + { + "bbox": [ + 105, + 384, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 505, + 398 + ], + "score": 1.0, + "content": "Out-of-distribution generalization Lastly, we discuss the out-of-distribution generalization. In", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 396, + 505, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 505, + 409 + ], + "score": 1.0, + "content": "offline RL, we rate the learned policy with three levels. Level I policies are able to strictly follow", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 408, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 408, + 505, + 420 + ], + "score": 1.0, + "content": "the behavior policy. Level II policies are able to combine sub-optimal policies in the bahevior", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 418, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 105, + 418, + 505, + 431 + ], + "score": 1.0, + "content": "policy. Level III policies are able to generalize to out-of-distribution actions. To visualize the out-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 429, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 106, + 429, + 505, + 442 + ], + "score": 1.0, + "content": "of-distribution generalization, we plot the KL divergence of the learned policy on the testing state", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 439, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 505, + 453 + ], + "score": 1.0, + "content": "distribution in Figure 7. In the hopper-mixed and halfcheetah-medium task, there are periodic spikes,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 451, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 505, + 464 + ], + "score": 1.0, + "content": "suggesting that the agents visit states which are not in the training distribution at test time. Although", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 463, + 504, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 463, + 504, + 475 + ], + "score": 1.0, + "content": "the results suggest that such generalization is correct, our approach is unable to explicitly quantify", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 473, + 249, + 485 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 249, + 485 + ], + "score": 1.0, + "content": "it. Thus, we leave it as future work.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 17 + }, + { + "type": "image", + "bbox": [ + 108, + 498, + 502, + 617 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 498, + 502, + 617 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 108, + 498, + 502, + 617 + ], + "spans": [ + { + "bbox": [ + 108, + 498, + 502, + 617 + ], + "score": 0.966, + "type": "image", + "image_path": "423e1a847c88d43168a412a1bcee0717bf24b6fbffd6ed2cce09d9a0542edad1.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 108, + 498, + 502, + 537.6666666666666 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 108, + 537.6666666666666, + 502, + 577.3333333333333 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 108, + 577.3333333333333, + 502, + 616.9999999999999 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 627, + 504, + 650 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 626, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 106, + 626, + 506, + 640 + ], + "score": 1.0, + "content": "Figure 7: The KL divergence between the learned policy and the behavior policy on the testing data", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 637, + 302, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 175, + 650 + ], + "score": 1.0, + "content": "distribution. The", + "type": "text" + }, + { + "bbox": [ + 176, + 640, + 183, + 648 + ], + "score": 0.74, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 637, + 302, + 650 + ], + "score": 1.0, + "content": "axis is the step in an episode.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + } + ], + "index": 24.25 + }, + { + "type": "text", + "bbox": [ + 107, + 677, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 675, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 675, + 505, + 689 + ], + "score": 1.0, + "content": "Performance sensitivity to the choices of target entropy During our experiments, we found that", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "the performance using the KL divergence as the behavior regularization method is very sensitive to", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "the choice of the target entropy. Policies trained with a larger entropy may not be able to capture the", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "narrow expert distribution within the behavior policy distribution. This phenomenon is most typical", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 720, + 370, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 370, + 732 + ], + "score": 1.0, + "content": "in the halfcheetah-medium-expert dataset as depicted in Figure 8.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29 + } + ], + "page_idx": 14, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "15", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 505, + 148 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 506, + 95 + ], + "score": 1.0, + "content": "Difference in training the behavior policy (Kumar et al., 2019) learns the behavior policy as", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 92, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 92, + 114, + 106 + ], + "score": 1.0, + "content": "a", + "type": "text" + }, + { + "bbox": [ + 115, + 94, + 122, + 105 + ], + "score": 0.83, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 122, + 92, + 505, + 106 + ], + "score": 1.0, + "content": "-VAE (Higgins et al., 2017) with MSE reconstruction loss. This is equivalent to maximizing", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "the log probability of a Gaussian distribution with fixed variance as the decoder output. However,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 290, + 127 + ], + "score": 1.0, + "content": "the variational lower bound does not hold in", + "type": "text" + }, + { + "bbox": [ + 291, + 116, + 298, + 127 + ], + "score": 0.83, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 299, + 114, + 505, + 127 + ], + "score": 1.0, + "content": "-VAE that breaks our derivation. In this paper, we", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 106, + 126, + 505, + 139 + ], + "score": 1.0, + "content": "learn the behavior policy as a regular VAE. The decoder outputs a Gaussian distribution with input-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 137, + 235, + 150 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 235, + 150 + ], + "score": 1.0, + "content": "conditioned mean and variance.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5, + "bbox_fs": [ + 105, + 81, + 506, + 150 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 165, + 505, + 198 + ], + "lines": [ + { + "bbox": [ + 105, + 164, + 506, + 177 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 506, + 177 + ], + "score": 1.0, + "content": "Gradient penalized policy evaluation Figure 6 suggests that the L2 norm of the gradient at the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 176, + 505, + 187 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 505, + 187 + ], + "score": 1.0, + "content": "out-of-distribution actions with the gradient penalty is much lower than that without the gradient", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 186, + 141, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 141, + 201 + ], + "score": 1.0, + "content": "penalty.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7, + "bbox_fs": [ + 105, + 164, + 506, + 201 + ] + }, + { + "type": "image", + "bbox": [ + 108, + 212, + 504, + 331 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 212, + 504, + 331 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 212, + 504, + 331 + ], + "spans": [ + { + "bbox": [ + 108, + 212, + 504, + 331 + ], + "score": 0.962, + "type": "image", + "image_path": "1e7b6a34bc8b6db03c161a6bd33f24a4fbe50c88de544e7755a5d07be157b435.jpg" + } + ] + } + ], + "index": 10, + "virtual_lines": [ + { + "bbox": [ + 108, + 212, + 504, + 251.66666666666666 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 108, + 251.66666666666666, + 504, + 291.3333333333333 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 108, + 291.3333333333333, + 504, + 331.0 + ], + "spans": [], + "index": 11 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 140, + 342, + 471, + 353 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 139, + 341, + 472, + 355 + ], + "spans": [ + { + "bbox": [ + 139, + 341, + 472, + 355 + ], + "score": 1.0, + "content": "Figure 6: Histogram of the L2 norm of the gradients for out-of-distribution actions", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + } + ], + "index": 11.0 + }, + { + "type": "text", + "bbox": [ + 106, + 385, + 505, + 484 + ], + "lines": [ + { + "bbox": [ + 105, + 384, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 505, + 398 + ], + "score": 1.0, + "content": "Out-of-distribution generalization Lastly, we discuss the out-of-distribution generalization. In", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 396, + 505, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 505, + 409 + ], + "score": 1.0, + "content": "offline RL, we rate the learned policy with three levels. Level I policies are able to strictly follow", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 408, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 408, + 505, + 420 + ], + "score": 1.0, + "content": "the behavior policy. Level II policies are able to combine sub-optimal policies in the bahevior", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 418, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 105, + 418, + 505, + 431 + ], + "score": 1.0, + "content": "policy. Level III policies are able to generalize to out-of-distribution actions. To visualize the out-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 429, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 106, + 429, + 505, + 442 + ], + "score": 1.0, + "content": "of-distribution generalization, we plot the KL divergence of the learned policy on the testing state", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 439, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 505, + 453 + ], + "score": 1.0, + "content": "distribution in Figure 7. In the hopper-mixed and halfcheetah-medium task, there are periodic spikes,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 451, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 505, + 464 + ], + "score": 1.0, + "content": "suggesting that the agents visit states which are not in the training distribution at test time. Although", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 463, + 504, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 463, + 504, + 475 + ], + "score": 1.0, + "content": "the results suggest that such generalization is correct, our approach is unable to explicitly quantify", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 473, + 249, + 485 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 249, + 485 + ], + "score": 1.0, + "content": "it. Thus, we leave it as future work.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 384, + 505, + 485 + ] + }, + { + "type": "image", + "bbox": [ + 108, + 498, + 502, + 617 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 498, + 502, + 617 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 108, + 498, + 502, + 617 + ], + "spans": [ + { + "bbox": [ + 108, + 498, + 502, + 617 + ], + "score": 0.966, + "type": "image", + "image_path": "423e1a847c88d43168a412a1bcee0717bf24b6fbffd6ed2cce09d9a0542edad1.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 108, + 498, + 502, + 537.6666666666666 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 108, + 537.6666666666666, + 502, + 577.3333333333333 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 108, + 577.3333333333333, + 502, + 616.9999999999999 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 627, + 504, + 650 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 626, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 106, + 626, + 506, + 640 + ], + "score": 1.0, + "content": "Figure 7: The KL divergence between the learned policy and the behavior policy on the testing data", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 637, + 302, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 175, + 650 + ], + "score": 1.0, + "content": "distribution. The", + "type": "text" + }, + { + "bbox": [ + 176, + 640, + 183, + 648 + ], + "score": 0.74, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 637, + 302, + 650 + ], + "score": 1.0, + "content": "axis is the step in an episode.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + } + ], + "index": 24.25 + }, + { + "type": "text", + "bbox": [ + 107, + 677, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 675, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 675, + 505, + 689 + ], + "score": 1.0, + "content": "Performance sensitivity to the choices of target entropy During our experiments, we found that", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "the performance using the KL divergence as the behavior regularization method is very sensitive to", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "the choice of the target entropy. Policies trained with a larger entropy may not be able to capture the", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "narrow expert distribution within the behavior policy distribution. This phenomenon is most typical", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 720, + 370, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 370, + 732 + ], + "score": 1.0, + "content": "in the halfcheetah-medium-expert dataset as depicted in Figure 8.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29, + "bbox_fs": [ + 105, + 675, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 107, + 81, + 503, + 199 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 81, + 503, + 199 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 81, + 503, + 199 + ], + "spans": [ + { + "bbox": [ + 107, + 81, + 503, + 199 + ], + "score": 0.965, + "type": "image", + "image_path": "e142754b28d4cb0fca25866e2b6b6daefced0991f27fffd724bcc1ecd202c59d.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 107, + 81, + 503, + 120.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 107, + 120.33333333333334, + 503, + 159.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 107, + 159.66666666666669, + 503, + 199.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 208, + 503, + 232 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 207, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 207, + 505, + 222 + ], + "score": 1.0, + "content": "Figure 8: The performance of the halfcheetah-medium-expert task on various choices of the target", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 104, + 218, + 143, + 235 + ], + "spans": [ + { + "bbox": [ + 104, + 218, + 143, + 235 + ], + "score": 1.0, + "content": "entropy.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "table", + "bbox": [ + 106, + 254, + 506, + 310 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 221, + 243, + 391, + 254 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 219, + 240, + 391, + 257 + ], + "spans": [ + { + "bbox": [ + 219, + 240, + 391, + 257 + ], + "score": 1.0, + "content": "Table 3: MMD-specific Hyper-parameters", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "table_body", + "bbox": [ + 106, + 254, + 506, + 310 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 254, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 106, + 254, + 506, + 310 + ], + "score": 0.98, + "html": "
Hyper-parameterhopper-medium-replay丨walker-medium-expert|halfcheetah-medium
σ in Laplacian kernel102010
EMMD0.20.20.3
Number of samples101010
", + "type": "table", + "image_path": "cf69dc14b4ba863a643b6d166bc8b65b454bc7f4b9cba67a13ef8cd61faca6fa.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 106, + 254, + 506, + 272.6666666666667 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 106, + 272.6666666666667, + 506, + 291.33333333333337 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 106, + 291.33333333333337, + 506, + 310.00000000000006 + ], + "spans": [], + "index": 8 + } + ] + } + ], + "index": 6.0 + }, + { + "type": "title", + "bbox": [ + 108, + 330, + 260, + 343 + ], + "lines": [ + { + "bbox": [ + 105, + 330, + 262, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 262, + 343 + ], + "score": 1.0, + "content": "E MISSING RELATED WORK", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 106, + 355, + 505, + 433 + ], + "lines": [ + { + "bbox": [ + 105, + 355, + 505, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 355, + 505, + 367 + ], + "score": 1.0, + "content": "For KL regularized policy improvement with fixed temperature, the optimal policy has a closed", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 366, + 505, + 378 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 505, + 378 + ], + "score": 1.0, + "content": "form solution (Wang et al., 2020). Although it avoids estimating the behavior policy, the issue with", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 376, + 505, + 390 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 505, + 390 + ], + "score": 1.0, + "content": "fixed temperature is that all the states are penalized equally. This leads to over-pessimistic for states", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 388, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 106, + 388, + 505, + 400 + ], + "score": 1.0, + "content": "with higher occurence in the dataset and over-optimistic for states with lower occurence. (Fox,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "score": 1.0, + "content": "2019) presents a closed-form expression for the regularization coefficient that completely eliminates", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 409, + 505, + 422 + ], + "spans": [ + { + "bbox": [ + 105, + 409, + 505, + 422 + ], + "score": 1.0, + "content": "the bias in entropy-regularized value updates. However, the softmax operator introduced by the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 420, + 338, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 420, + 338, + 434 + ], + "score": 1.0, + "content": "approach makes it hard to use in continuous action space.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13 + }, + { + "type": "title", + "bbox": [ + 108, + 448, + 267, + 461 + ], + "lines": [ + { + "bbox": [ + 105, + 447, + 269, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 269, + 463 + ], + "score": 1.0, + "content": "F IMPLEMENTATION DETAILS", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 106, + 473, + 505, + 518 + ], + "lines": [ + { + "bbox": [ + 106, + 473, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 505, + 486 + ], + "score": 1.0, + "content": "Computation of the analytical KL upper bound To reduce the variance when computing the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 484, + 506, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 268, + 497 + ], + "score": 1.0, + "content": "analytical KL upper bound, we sample", + "type": "text" + }, + { + "bbox": [ + 268, + 485, + 277, + 495 + ], + "score": 0.79, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 277, + 484, + 338, + 497 + ], + "score": 1.0, + "content": "latent variable", + "type": "text" + }, + { + "bbox": [ + 339, + 486, + 346, + 495 + ], + "score": 0.77, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 346, + 484, + 479, + 497 + ], + "score": 1.0, + "content": "and compute the average of the", + "type": "text" + }, + { + "bbox": [ + 479, + 485, + 487, + 495 + ], + "score": 0.65, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 484, + 506, + 497 + ], + "score": 1.0, + "content": "KL", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 495, + 506, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 277, + 508 + ], + "score": 1.0, + "content": "upper bounds. In our experiments, we set", + "type": "text" + }, + { + "bbox": [ + 277, + 496, + 304, + 506 + ], + "score": 0.9, + "content": "L = 5", + "type": "inline_equation" + }, + { + "bbox": [ + 305, + 495, + 506, + 508 + ], + "score": 1.0, + "content": ". Note that it doesn’t reduce the bias of the upper", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 506, + 137, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 137, + 519 + ], + "score": 1.0, + "content": "bound.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 105, + 529, + 504, + 553 + ], + "lines": [ + { + "bbox": [ + 105, + 528, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 505, + 543 + ], + "score": 1.0, + "content": "Reward scaling Any affine transformation of the reward function does not change the optimal", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 540, + 401, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 364, + 555 + ], + "score": 1.0, + "content": "policy of the MDP. In our experiments, we rescale the reward to", + "type": "text" + }, + { + "bbox": [ + 364, + 541, + 385, + 553 + ], + "score": 0.77, + "content": "[ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 540, + 401, + 555 + ], + "score": 1.0, + "content": "as:", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "interline_equation", + "bbox": [ + 239, + 557, + 372, + 571 + ], + "lines": [ + { + "bbox": [ + 239, + 557, + 372, + 571 + ], + "spans": [ + { + "bbox": [ + 239, + 557, + 372, + 571 + ], + "score": 0.91, + "content": "r ^ { \\prime } = ( r - r _ { m i n } ) / ( r _ { m a x } - r _ { m i n } )", + "type": "interline_equation", + "image_path": "7b065230b81c98ee8e5bba5098cf4ca7471265f68c10ac661fe218a2a28d60ab.jpg" + } + ] + } + ], + "index": 24, + "virtual_lines": [ + { + "bbox": [ + 239, + 557, + 372, + 571 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 576, + 421, + 588 + ], + "lines": [ + { + "bbox": [ + 105, + 575, + 423, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 575, + 133, + 590 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 578, + 155, + 588 + ], + "score": 0.88, + "content": "r _ { m a x }", + "type": "inline_equation" + }, + { + "bbox": [ + 156, + 575, + 173, + 590 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 174, + 578, + 194, + 588 + ], + "score": 0.87, + "content": "r _ { m i n }", + "type": "inline_equation" + }, + { + "bbox": [ + 195, + 575, + 423, + 590 + ], + "score": 1.0, + "content": "is the maximum and the minimum reward in the dataset.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 599, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 599, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 505, + 613 + ], + "score": 1.0, + "content": "Entropy regularization The KL divergence is the sum of negative entropy of the learned policy", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 611, + 505, + 624 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 405, + 624 + ], + "score": 1.0, + "content": "plus the cross entropy between the learned policy and the behavior policy:", + "type": "text" + }, + { + "bbox": [ + 405, + 611, + 505, + 623 + ], + "score": 0.89, + "content": "\\bar { \\mathcal { D } } _ { \\mathrm { K L } } ( \\pi _ { \\theta } ( \\cdot | s ) , \\pi _ { \\beta } ( \\cdot | \\bar { s } ) ) \\stackrel { \\cdot } { = }", + "type": "inline_equation" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 621, + 506, + 635 + ], + "spans": [ + { + "bbox": [ + 106, + 622, + 252, + 634 + ], + "score": 0.92, + "content": "\\bar { - \\mathcal { H } } ( \\pi _ { \\theta } ( \\cdot | s ) ) + \\mathcal { H } ( \\bar { \\pi _ { \\theta } } ( \\cdot | s ) , \\pi _ { \\beta } ( \\cdot | s ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 621, + 506, + 635 + ], + "score": 1.0, + "content": ". When the learned policy distribution violates the KL con-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 633, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 505, + 645 + ], + "score": 1.0, + "content": "straints, the KL divergence between the policy distribution and the behavior distribution is decreased", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 643, + 506, + 657 + ], + "spans": [ + { + "bbox": [ + 104, + 643, + 506, + 657 + ], + "score": 1.0, + "content": "by the optimizer. This is equivalent to increasing the entropy of the learned policy and decreasing", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "score": 1.0, + "content": "the cross entropy between the learned policy and the behavior policy. In soft actor-critic (Haarnoja", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "et al., 2018a), the minimum entropy of the learned policy is enforced to encourage exploration.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "score": 1.0, + "content": "However, due to the absence of exploration, stochastic policy with large entropy will sample out-of-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "score": 1.0, + "content": "distribution actions when computing the target Q values in Equation 2. If such values are overesti-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "mated, the policy will exploit the erroneous Q values when performing the policy improvement in", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 710, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 506, + 722 + ], + "score": 1.0, + "content": "Equation 8 and lead to failure, which can’t be corrected without more data. Thus, we maintain the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 722, + 495, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 722, + 495, + 732 + ], + "score": 1.0, + "content": "maximum entropy of the learned policy using the technique proposed in (Haarnoja et al., 2018b).", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 31.5 + } + ], + "page_idx": 15, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 27, + 307, + 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 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "16", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 107, + 81, + 503, + 199 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 81, + 503, + 199 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 81, + 503, + 199 + ], + "spans": [ + { + "bbox": [ + 107, + 81, + 503, + 199 + ], + "score": 0.965, + "type": "image", + "image_path": "e142754b28d4cb0fca25866e2b6b6daefced0991f27fffd724bcc1ecd202c59d.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 107, + 81, + 503, + 120.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 107, + 120.33333333333334, + 503, + 159.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 107, + 159.66666666666669, + 503, + 199.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 208, + 503, + 232 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 207, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 207, + 505, + 222 + ], + "score": 1.0, + "content": "Figure 8: The performance of the halfcheetah-medium-expert task on various choices of the target", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 104, + 218, + 143, + 235 + ], + "spans": [ + { + "bbox": [ + 104, + 218, + 143, + 235 + ], + "score": 1.0, + "content": "entropy.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "table", + "bbox": [ + 106, + 254, + 506, + 310 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 221, + 243, + 391, + 254 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 219, + 240, + 391, + 257 + ], + "spans": [ + { + "bbox": [ + 219, + 240, + 391, + 257 + ], + "score": 1.0, + "content": "Table 3: MMD-specific Hyper-parameters", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "table_body", + "bbox": [ + 106, + 254, + 506, + 310 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 254, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 106, + 254, + 506, + 310 + ], + "score": 0.98, + "html": "
Hyper-parameterhopper-medium-replay丨walker-medium-expert|halfcheetah-medium
σ in Laplacian kernel102010
EMMD0.20.20.3
Number of samples101010
", + "type": "table", + "image_path": "cf69dc14b4ba863a643b6d166bc8b65b454bc7f4b9cba67a13ef8cd61faca6fa.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 106, + 254, + 506, + 272.6666666666667 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 106, + 272.6666666666667, + 506, + 291.33333333333337 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 106, + 291.33333333333337, + 506, + 310.00000000000006 + ], + "spans": [], + "index": 8 + } + ] + } + ], + "index": 6.0 + }, + { + "type": "title", + "bbox": [ + 108, + 330, + 260, + 343 + ], + "lines": [ + { + "bbox": [ + 105, + 330, + 262, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 262, + 343 + ], + "score": 1.0, + "content": "E MISSING RELATED WORK", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 106, + 355, + 505, + 433 + ], + "lines": [ + { + "bbox": [ + 105, + 355, + 505, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 355, + 505, + 367 + ], + "score": 1.0, + "content": "For KL regularized policy improvement with fixed temperature, the optimal policy has a closed", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 366, + 505, + 378 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 505, + 378 + ], + "score": 1.0, + "content": "form solution (Wang et al., 2020). Although it avoids estimating the behavior policy, the issue with", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 376, + 505, + 390 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 505, + 390 + ], + "score": 1.0, + "content": "fixed temperature is that all the states are penalized equally. This leads to over-pessimistic for states", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 388, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 106, + 388, + 505, + 400 + ], + "score": 1.0, + "content": "with higher occurence in the dataset and over-optimistic for states with lower occurence. (Fox,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "score": 1.0, + "content": "2019) presents a closed-form expression for the regularization coefficient that completely eliminates", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 409, + 505, + 422 + ], + "spans": [ + { + "bbox": [ + 105, + 409, + 505, + 422 + ], + "score": 1.0, + "content": "the bias in entropy-regularized value updates. However, the softmax operator introduced by the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 420, + 338, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 420, + 338, + 434 + ], + "score": 1.0, + "content": "approach makes it hard to use in continuous action space.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13, + "bbox_fs": [ + 105, + 355, + 505, + 434 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 448, + 267, + 461 + ], + "lines": [ + { + "bbox": [ + 105, + 447, + 269, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 269, + 463 + ], + "score": 1.0, + "content": "F IMPLEMENTATION DETAILS", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 106, + 473, + 505, + 518 + ], + "lines": [ + { + "bbox": [ + 106, + 473, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 505, + 486 + ], + "score": 1.0, + "content": "Computation of the analytical KL upper bound To reduce the variance when computing the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 484, + 506, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 268, + 497 + ], + "score": 1.0, + "content": "analytical KL upper bound, we sample", + "type": "text" + }, + { + "bbox": [ + 268, + 485, + 277, + 495 + ], + "score": 0.79, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 277, + 484, + 338, + 497 + ], + "score": 1.0, + "content": "latent variable", + "type": "text" + }, + { + "bbox": [ + 339, + 486, + 346, + 495 + ], + "score": 0.77, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 346, + 484, + 479, + 497 + ], + "score": 1.0, + "content": "and compute the average of the", + "type": "text" + }, + { + "bbox": [ + 479, + 485, + 487, + 495 + ], + "score": 0.65, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 484, + 506, + 497 + ], + "score": 1.0, + "content": "KL", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 495, + 506, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 277, + 508 + ], + "score": 1.0, + "content": "upper bounds. In our experiments, we set", + "type": "text" + }, + { + "bbox": [ + 277, + 496, + 304, + 506 + ], + "score": 0.9, + "content": "L = 5", + "type": "inline_equation" + }, + { + "bbox": [ + 305, + 495, + 506, + 508 + ], + "score": 1.0, + "content": ". Note that it doesn’t reduce the bias of the upper", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 506, + 137, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 137, + 519 + ], + "score": 1.0, + "content": "bound.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 473, + 506, + 519 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 529, + 504, + 553 + ], + "lines": [ + { + "bbox": [ + 105, + 528, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 505, + 543 + ], + "score": 1.0, + "content": "Reward scaling Any affine transformation of the reward function does not change the optimal", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 540, + 401, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 364, + 555 + ], + "score": 1.0, + "content": "policy of the MDP. In our experiments, we rescale the reward to", + "type": "text" + }, + { + "bbox": [ + 364, + 541, + 385, + 553 + ], + "score": 0.77, + "content": "[ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 540, + 401, + 555 + ], + "score": 1.0, + "content": "as:", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 528, + 505, + 555 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 239, + 557, + 372, + 571 + ], + "lines": [ + { + "bbox": [ + 239, + 557, + 372, + 571 + ], + "spans": [ + { + "bbox": [ + 239, + 557, + 372, + 571 + ], + "score": 0.91, + "content": "r ^ { \\prime } = ( r - r _ { m i n } ) / ( r _ { m a x } - r _ { m i n } )", + "type": "interline_equation", + "image_path": "7b065230b81c98ee8e5bba5098cf4ca7471265f68c10ac661fe218a2a28d60ab.jpg" + } + ] + } + ], + "index": 24, + "virtual_lines": [ + { + "bbox": [ + 239, + 557, + 372, + 571 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 576, + 421, + 588 + ], + "lines": [ + { + "bbox": [ + 105, + 575, + 423, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 575, + 133, + 590 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 578, + 155, + 588 + ], + "score": 0.88, + "content": "r _ { m a x }", + "type": "inline_equation" + }, + { + "bbox": [ + 156, + 575, + 173, + 590 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 174, + 578, + 194, + 588 + ], + "score": 0.87, + "content": "r _ { m i n }", + "type": "inline_equation" + }, + { + "bbox": [ + 195, + 575, + 423, + 590 + ], + "score": 1.0, + "content": "is the maximum and the minimum reward in the dataset.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 575, + 423, + 590 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 599, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 599, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 505, + 613 + ], + "score": 1.0, + "content": "Entropy regularization The KL divergence is the sum of negative entropy of the learned policy", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 611, + 505, + 624 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 405, + 624 + ], + "score": 1.0, + "content": "plus the cross entropy between the learned policy and the behavior policy:", + "type": "text" + }, + { + "bbox": [ + 405, + 611, + 505, + 623 + ], + "score": 0.89, + "content": "\\bar { \\mathcal { D } } _ { \\mathrm { K L } } ( \\pi _ { \\theta } ( \\cdot | s ) , \\pi _ { \\beta } ( \\cdot | \\bar { s } ) ) \\stackrel { \\cdot } { = }", + "type": "inline_equation" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 621, + 506, + 635 + ], + "spans": [ + { + "bbox": [ + 106, + 622, + 252, + 634 + ], + "score": 0.92, + "content": "\\bar { - \\mathcal { H } } ( \\pi _ { \\theta } ( \\cdot | s ) ) + \\mathcal { H } ( \\bar { \\pi _ { \\theta } } ( \\cdot | s ) , \\pi _ { \\beta } ( \\cdot | s ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 621, + 506, + 635 + ], + "score": 1.0, + "content": ". When the learned policy distribution violates the KL con-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 633, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 505, + 645 + ], + "score": 1.0, + "content": "straints, the KL divergence between the policy distribution and the behavior distribution is decreased", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 643, + 506, + 657 + ], + "spans": [ + { + "bbox": [ + 104, + 643, + 506, + 657 + ], + "score": 1.0, + "content": "by the optimizer. This is equivalent to increasing the entropy of the learned policy and decreasing", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "score": 1.0, + "content": "the cross entropy between the learned policy and the behavior policy. In soft actor-critic (Haarnoja", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "et al., 2018a), the minimum entropy of the learned policy is enforced to encourage exploration.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "score": 1.0, + "content": "However, due to the absence of exploration, stochastic policy with large entropy will sample out-of-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "score": 1.0, + "content": "distribution actions when computing the target Q values in Equation 2. If such values are overesti-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "mated, the policy will exploit the erroneous Q values when performing the policy improvement in", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 710, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 506, + 722 + ], + "score": 1.0, + "content": "Equation 8 and lead to failure, which can’t be corrected without more data. Thus, we maintain the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 722, + 495, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 722, + 495, + 732 + ], + "score": 1.0, + "content": "maximum entropy of the learned policy using the technique proposed in (Haarnoja et al., 2018b).", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 31.5, + "bbox_fs": [ + 104, + 599, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 505, + 149 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Initialization If the dataset is collected using a narrow policy distribution in a high dimensional", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "space (e.g. human demonstration), the constrained optimization problem using dual gradient descent", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "finds it difficult to converge if random initialization is used for the policy network. To mitigate", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 505, + 128 + ], + "score": 1.0, + "content": "this issue, we start with a policy that has the minimum KL divergence with the behavior policy:", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 126, + 507, + 140 + ], + "spans": [ + { + "bbox": [ + 106, + 126, + 237, + 139 + ], + "score": 0.9, + "content": "\\begin{array} { r } { \\pi _ { \\theta } \\ = \\ \\arg \\operatorname* { m i n } _ { \\pi _ { \\theta } \\in \\Pi } \\mathcal { D } _ { \\mathrm { K L } } ( \\pi , \\pi _ { \\beta } ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 237, + 126, + 270, + 140 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 270, + 127, + 279, + 137 + ], + "score": 0.36, + "content": "\\Pi", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 126, + 507, + 140 + ], + "score": 1.0, + "content": "represents a family of policy types. In this work, we", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 136, + 452, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 136, + 142, + 150 + ], + "score": 1.0, + "content": "consider", + "type": "text" + }, + { + "bbox": [ + 143, + 138, + 152, + 147 + ], + "score": 0.33, + "content": "\\Pi", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 136, + 432, + 150 + ], + "score": 1.0, + "content": "as Gaussian policies. Correspondingly, we initialize the Q network to", + "type": "text" + }, + { + "bbox": [ + 432, + 137, + 449, + 149 + ], + "score": 0.9, + "content": "Q ^ { \\pi _ { \\theta } }", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 136, + 452, + 150 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 106, + 160, + 505, + 217 + ], + "lines": [ + { + "bbox": [ + 106, + 161, + 505, + 173 + ], + "spans": [ + { + "bbox": [ + 106, + 161, + 505, + 173 + ], + "score": 1.0, + "content": "Policy network Our policy network is a 3-layer feed-forward neural network. The size of each", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 104, + 170, + 506, + 186 + ], + "spans": [ + { + "bbox": [ + 104, + 170, + 506, + 186 + ], + "score": 1.0, + "content": "hidden layer is 512. We apply RELU activation (Agarap, 2018) after each hidden layer. Following", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 183, + 505, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 183, + 505, + 195 + ], + "score": 1.0, + "content": "(Haarnoja et al., 2018a), the output is a Gaussian distribution with diagonal covariance matrix. We", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 193, + 506, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 506, + 207 + ], + "score": 1.0, + "content": "apply tanh to enforce the action bounds. The log-likelihood after applying the tanh function has", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 205, + 491, + 217 + ], + "spans": [ + { + "bbox": [ + 106, + 205, + 491, + 217 + ], + "score": 1.0, + "content": "a simple closed form solution. We refer to (Haarnoja et al., 2018a) Appendix C for more details.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 227, + 505, + 284 + ], + "lines": [ + { + "bbox": [ + 105, + 228, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 105, + 228, + 505, + 241 + ], + "score": 1.0, + "content": "Q network Following (Haarnoja et al., 2018a; Fujimoto et al., 2018a; Wu et al., 2019), we train", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 239, + 506, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 219, + 254 + ], + "score": 1.0, + "content": "two independent Q network", + "type": "text" + }, + { + "bbox": [ + 220, + 240, + 270, + 252 + ], + "score": 0.92, + "content": "\\{ Q _ { \\psi _ { 1 } } , Q _ { \\psi _ { 2 } } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 239, + 506, + 254 + ], + "score": 1.0, + "content": "to penalize uncertainty over the future states. We maintain", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 104, + 250, + 507, + 264 + ], + "spans": [ + { + "bbox": [ + 104, + 250, + 185, + 264 + ], + "score": 1.0, + "content": "a target Q network", + "type": "text" + }, + { + "bbox": [ + 186, + 251, + 241, + 263 + ], + "score": 0.92, + "content": "\\{ Q _ { \\psi _ { 1 } ^ { \\prime } } , Q _ { \\psi _ { 2 } ^ { \\prime } } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 250, + 507, + 264 + ], + "score": 1.0, + "content": "with the same architecture and update the target weights using a", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 261, + 505, + 275 + ], + "spans": [ + { + "bbox": [ + 105, + 261, + 505, + 275 + ], + "score": 1.0, + "content": "weighted sum of the current Q network and the target Q network. When computing the target Q", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 273, + 373, + 285 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 373, + 285 + ], + "score": 1.0, + "content": "values, we simply take the minimum value of the two Q networks:", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13 + }, + { + "type": "interline_equation", + "bbox": [ + 240, + 289, + 371, + 308 + ], + "lines": [ + { + "bbox": [ + 240, + 289, + 371, + 308 + ], + "spans": [ + { + "bbox": [ + 240, + 289, + 371, + 308 + ], + "score": 0.93, + "content": "Q _ { \\psi ^ { \\prime } } ( s ^ { \\prime } , a ^ { \\prime } ) = \\operatorname* { m i n } _ { j = 1 , 2 } Q _ { \\psi ^ { \\prime } { } _ { j } } ( s ^ { \\prime } , a ^ { \\prime } )", + "type": "interline_equation", + "image_path": "91f888bc5e8404b3274b37b1735018515c811d620f9fb94f82da42430c78b448.jpg" + } + ] + } + ], + "index": 16, + "virtual_lines": [ + { + "bbox": [ + 240, + 289, + 371, + 308 + ], + "spans": [], + "index": 16 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 313, + 504, + 336 + ], + "lines": [ + { + "bbox": [ + 106, + 313, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 106, + 313, + 505, + 326 + ], + "score": 1.0, + "content": "Each Q network is a 3-layer feed-forward neural network. The size of each hidden layer is 256. We", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 324, + 360, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 360, + 338 + ], + "score": 1.0, + "content": "apply RELU activation (Agarap, 2018) after each hidden layer.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 106, + 347, + 505, + 448 + ], + "lines": [ + { + "bbox": [ + 106, + 348, + 505, + 361 + ], + "spans": [ + { + "bbox": [ + 106, + 348, + 505, + 361 + ], + "score": 1.0, + "content": "Behavior policy network Following the previous work (Fujimoto et al., 2018b; Kumar et al.,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 359, + 506, + 371 + ], + "spans": [ + { + "bbox": [ + 106, + 359, + 506, + 371 + ], + "score": 1.0, + "content": "2019), we learn a conditional variational auto-encoder (Kingma & Welling, 2014) as our behavior", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 370, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 505, + 383 + ], + "score": 1.0, + "content": "policy network. The encoder takes a pair of states and actions, and outputs a Gaussian latent variable", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 107, + 381, + 504, + 393 + ], + "spans": [ + { + "bbox": [ + 107, + 382, + 115, + 391 + ], + "score": 0.73, + "content": "Z", + "type": "inline_equation" + }, + { + "bbox": [ + 115, + 381, + 277, + 393 + ], + "score": 1.0, + "content": ". The decoder takes sampled latent code", + "type": "text" + }, + { + "bbox": [ + 277, + 383, + 284, + 391 + ], + "score": 0.75, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 381, + 504, + 393 + ], + "score": 1.0, + "content": "and states, and outputs a mixture of Gaussian distribu-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 392, + 504, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 504, + 404 + ], + "score": 1.0, + "content": "tions. Both the architecture of the encoder and the decoder is a 3-layer feed-forward neural network.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 402, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 505, + 415 + ], + "score": 1.0, + "content": "The size of each hidden layer is 512. The activation is relu (Agarap, 2018). To avoid epistemic", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 414, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 192, + 426 + ], + "score": 1.0, + "content": "uncertainty, we train", + "type": "text" + }, + { + "bbox": [ + 193, + 415, + 202, + 424 + ], + "score": 0.76, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 414, + 506, + 426 + ], + "score": 1.0, + "content": "ensembles of behavior policy networks. At test time, we randomly select", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 425, + 506, + 438 + ], + "spans": [ + { + "bbox": [ + 106, + 425, + 310, + 438 + ], + "score": 1.0, + "content": "one model to perform the calculations. We found", + "type": "text" + }, + { + "bbox": [ + 310, + 425, + 340, + 435 + ], + "score": 0.9, + "content": "B = 3", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 425, + 506, + 438 + ], + "score": 1.0, + "content": "is sufficient for all the experiments. We", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 436, + 369, + 449 + ], + "spans": [ + { + "bbox": [ + 106, + 436, + 286, + 449 + ], + "score": 1.0, + "content": "pre-train the the behavior policy network for", + "type": "text" + }, + { + "bbox": [ + 286, + 436, + 308, + 447 + ], + "score": 0.26, + "content": "4 0 0 \\mathrm { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 436, + 369, + 449 + ], + "score": 1.0, + "content": "gradient steps.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 459, + 505, + 504 + ], + "lines": [ + { + "bbox": [ + 107, + 460, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 107, + 462, + 114, + 469 + ], + "score": 0.69, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 115, + 460, + 179, + 471 + ], + "score": 1.0, + "content": "network The", + "type": "text" + }, + { + "bbox": [ + 179, + 461, + 187, + 469 + ], + "score": 0.77, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 460, + 505, + 471 + ], + "score": 1.0, + "content": "network takes in a state and outputs the Lagrange multiplier for the state. The", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 470, + 505, + 482 + ], + "spans": [ + { + "bbox": [ + 106, + 470, + 184, + 482 + ], + "score": 1.0, + "content": "architecture of the", + "type": "text" + }, + { + "bbox": [ + 185, + 473, + 192, + 480 + ], + "score": 0.73, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 193, + 470, + 505, + 482 + ], + "score": 1.0, + "content": "network is a 3-layer feed-forward neural network with relu (Agarap, 2018)", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 482, + 505, + 493 + ], + "spans": [ + { + "bbox": [ + 106, + 482, + 505, + 493 + ], + "score": 1.0, + "content": "activation. The size of each hidden layer is 256. We use softplus activation after the output to", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 493, + 258, + 505 + ], + "spans": [ + { + "bbox": [ + 106, + 493, + 258, + 505 + ], + "score": 1.0, + "content": "ensure that all the values are positive.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5 + }, + { + "type": "table", + "bbox": [ + 188, + 526, + 423, + 669 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 236, + 515, + 375, + 525 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 235, + 513, + 376, + 529 + ], + "spans": [ + { + "bbox": [ + 235, + 513, + 376, + 529 + ], + "score": 1.0, + "content": "Table 4: Default hyper-parameters", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "table_body", + "bbox": [ + 188, + 526, + 423, + 669 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 188, + 526, + 423, + 669 + ], + "spans": [ + { + "bbox": [ + 188, + 526, + 423, + 669 + ], + "score": 0.982, + "html": "
Hyper-parameterValue (Gym/Adroit)
OptimizerAdam (Kingma & Ba,2015)
Policy learning rate5e-6/5e-8
Q network learning rate3e-4
α learning ratele-5/1e-7
batch size100
Target update rate T1e-3
Discount factor y0.99
Initial β10
β learning rate1e-3
Steps per epoch T2000
Number of epochs500
", + "type": "table", + "image_path": "30e2d602098560b912248512e1bd878e2d277cf0ae8755ec1d886c59e55e2dc9.jpg" + } + ] + } + ], + "index": 38, + "virtual_lines": [ + { + "bbox": [ + 188, + 526, + 423, + 539.0 + ], + "spans": [], + "index": 33 + }, + { + "bbox": [ + 188, + 539.0, + 423, + 552.0 + ], + "spans": [], + "index": 34 + }, + { + "bbox": [ + 188, + 552.0, + 423, + 565.0 + ], + "spans": [], + "index": 35 + }, + { + "bbox": [ + 188, + 565.0, + 423, + 578.0 + ], + "spans": [], + "index": 36 + }, + { + "bbox": [ + 188, + 578.0, + 423, + 591.0 + ], + "spans": [], + "index": 37 + }, + { + "bbox": [ + 188, + 591.0, + 423, + 604.0 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 188, + 604.0, + 423, + 617.0 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 188, + 617.0, + 423, + 630.0 + ], + "spans": [], + "index": 40 + }, + { + "bbox": [ + 188, + 630.0, + 423, + 643.0 + ], + "spans": [], + "index": 41 + }, + { + "bbox": [ + 188, + 643.0, + 423, + 656.0 + ], + "spans": [], + "index": 42 + }, + { + "bbox": [ + 188, + 656.0, + 423, + 669.0 + ], + "spans": [], + "index": 43 + } + ] + } + ], + "index": 35.0 + } + ], + "page_idx": 16, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "17", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 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 2021", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 505, + 149 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Initialization If the dataset is collected using a narrow policy distribution in a high dimensional", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "space (e.g. human demonstration), the constrained optimization problem using dual gradient descent", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "finds it difficult to converge if random initialization is used for the policy network. To mitigate", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 505, + 128 + ], + "score": 1.0, + "content": "this issue, we start with a policy that has the minimum KL divergence with the behavior policy:", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 126, + 507, + 140 + ], + "spans": [ + { + "bbox": [ + 106, + 126, + 237, + 139 + ], + "score": 0.9, + "content": "\\begin{array} { r } { \\pi _ { \\theta } \\ = \\ \\arg \\operatorname* { m i n } _ { \\pi _ { \\theta } \\in \\Pi } \\mathcal { D } _ { \\mathrm { K L } } ( \\pi , \\pi _ { \\beta } ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 237, + 126, + 270, + 140 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 270, + 127, + 279, + 137 + ], + "score": 0.36, + "content": "\\Pi", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 126, + 507, + 140 + ], + "score": 1.0, + "content": "represents a family of policy types. In this work, we", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 136, + 452, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 136, + 142, + 150 + ], + "score": 1.0, + "content": "consider", + "type": "text" + }, + { + "bbox": [ + 143, + 138, + 152, + 147 + ], + "score": 0.33, + "content": "\\Pi", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 136, + 432, + 150 + ], + "score": 1.0, + "content": "as Gaussian policies. Correspondingly, we initialize the Q network to", + "type": "text" + }, + { + "bbox": [ + 432, + 137, + 449, + 149 + ], + "score": 0.9, + "content": "Q ^ { \\pi _ { \\theta } }", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 136, + 452, + 150 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5, + "bbox_fs": [ + 105, + 82, + 507, + 150 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 160, + 505, + 217 + ], + "lines": [ + { + "bbox": [ + 106, + 161, + 505, + 173 + ], + "spans": [ + { + "bbox": [ + 106, + 161, + 505, + 173 + ], + "score": 1.0, + "content": "Policy network Our policy network is a 3-layer feed-forward neural network. The size of each", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 104, + 170, + 506, + 186 + ], + "spans": [ + { + "bbox": [ + 104, + 170, + 506, + 186 + ], + "score": 1.0, + "content": "hidden layer is 512. We apply RELU activation (Agarap, 2018) after each hidden layer. Following", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 183, + 505, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 183, + 505, + 195 + ], + "score": 1.0, + "content": "(Haarnoja et al., 2018a), the output is a Gaussian distribution with diagonal covariance matrix. We", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 193, + 506, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 506, + 207 + ], + "score": 1.0, + "content": "apply tanh to enforce the action bounds. The log-likelihood after applying the tanh function has", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 205, + 491, + 217 + ], + "spans": [ + { + "bbox": [ + 106, + 205, + 491, + 217 + ], + "score": 1.0, + "content": "a simple closed form solution. We refer to (Haarnoja et al., 2018a) Appendix C for more details.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8, + "bbox_fs": [ + 104, + 161, + 506, + 217 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 227, + 505, + 284 + ], + "lines": [ + { + "bbox": [ + 105, + 228, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 105, + 228, + 505, + 241 + ], + "score": 1.0, + "content": "Q network Following (Haarnoja et al., 2018a; Fujimoto et al., 2018a; Wu et al., 2019), we train", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 239, + 506, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 219, + 254 + ], + "score": 1.0, + "content": "two independent Q network", + "type": "text" + }, + { + "bbox": [ + 220, + 240, + 270, + 252 + ], + "score": 0.92, + "content": "\\{ Q _ { \\psi _ { 1 } } , Q _ { \\psi _ { 2 } } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 239, + 506, + 254 + ], + "score": 1.0, + "content": "to penalize uncertainty over the future states. We maintain", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 104, + 250, + 507, + 264 + ], + "spans": [ + { + "bbox": [ + 104, + 250, + 185, + 264 + ], + "score": 1.0, + "content": "a target Q network", + "type": "text" + }, + { + "bbox": [ + 186, + 251, + 241, + 263 + ], + "score": 0.92, + "content": "\\{ Q _ { \\psi _ { 1 } ^ { \\prime } } , Q _ { \\psi _ { 2 } ^ { \\prime } } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 250, + 507, + 264 + ], + "score": 1.0, + "content": "with the same architecture and update the target weights using a", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 261, + 505, + 275 + ], + "spans": [ + { + "bbox": [ + 105, + 261, + 505, + 275 + ], + "score": 1.0, + "content": "weighted sum of the current Q network and the target Q network. When computing the target Q", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 273, + 373, + 285 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 373, + 285 + ], + "score": 1.0, + "content": "values, we simply take the minimum value of the two Q networks:", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13, + "bbox_fs": [ + 104, + 228, + 507, + 285 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 240, + 289, + 371, + 308 + ], + "lines": [ + { + "bbox": [ + 240, + 289, + 371, + 308 + ], + "spans": [ + { + "bbox": [ + 240, + 289, + 371, + 308 + ], + "score": 0.93, + "content": "Q _ { \\psi ^ { \\prime } } ( s ^ { \\prime } , a ^ { \\prime } ) = \\operatorname* { m i n } _ { j = 1 , 2 } Q _ { \\psi ^ { \\prime } { } _ { j } } ( s ^ { \\prime } , a ^ { \\prime } )", + "type": "interline_equation", + "image_path": "91f888bc5e8404b3274b37b1735018515c811d620f9fb94f82da42430c78b448.jpg" + } + ] + } + ], + "index": 16, + "virtual_lines": [ + { + "bbox": [ + 240, + 289, + 371, + 308 + ], + "spans": [], + "index": 16 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 313, + 504, + 336 + ], + "lines": [ + { + "bbox": [ + 106, + 313, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 106, + 313, + 505, + 326 + ], + "score": 1.0, + "content": "Each Q network is a 3-layer feed-forward neural network. The size of each hidden layer is 256. We", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 324, + 360, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 360, + 338 + ], + "score": 1.0, + "content": "apply RELU activation (Agarap, 2018) after each hidden layer.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5, + "bbox_fs": [ + 105, + 313, + 505, + 338 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 347, + 505, + 448 + ], + "lines": [ + { + "bbox": [ + 106, + 348, + 505, + 361 + ], + "spans": [ + { + "bbox": [ + 106, + 348, + 505, + 361 + ], + "score": 1.0, + "content": "Behavior policy network Following the previous work (Fujimoto et al., 2018b; Kumar et al.,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 359, + 506, + 371 + ], + "spans": [ + { + "bbox": [ + 106, + 359, + 506, + 371 + ], + "score": 1.0, + "content": "2019), we learn a conditional variational auto-encoder (Kingma & Welling, 2014) as our behavior", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 370, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 505, + 383 + ], + "score": 1.0, + "content": "policy network. The encoder takes a pair of states and actions, and outputs a Gaussian latent variable", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 107, + 381, + 504, + 393 + ], + "spans": [ + { + "bbox": [ + 107, + 382, + 115, + 391 + ], + "score": 0.73, + "content": "Z", + "type": "inline_equation" + }, + { + "bbox": [ + 115, + 381, + 277, + 393 + ], + "score": 1.0, + "content": ". The decoder takes sampled latent code", + "type": "text" + }, + { + "bbox": [ + 277, + 383, + 284, + 391 + ], + "score": 0.75, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 381, + 504, + 393 + ], + "score": 1.0, + "content": "and states, and outputs a mixture of Gaussian distribu-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 392, + 504, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 504, + 404 + ], + "score": 1.0, + "content": "tions. Both the architecture of the encoder and the decoder is a 3-layer feed-forward neural network.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 402, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 505, + 415 + ], + "score": 1.0, + "content": "The size of each hidden layer is 512. The activation is relu (Agarap, 2018). To avoid epistemic", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 414, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 192, + 426 + ], + "score": 1.0, + "content": "uncertainty, we train", + "type": "text" + }, + { + "bbox": [ + 193, + 415, + 202, + 424 + ], + "score": 0.76, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 414, + 506, + 426 + ], + "score": 1.0, + "content": "ensembles of behavior policy networks. At test time, we randomly select", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 425, + 506, + 438 + ], + "spans": [ + { + "bbox": [ + 106, + 425, + 310, + 438 + ], + "score": 1.0, + "content": "one model to perform the calculations. We found", + "type": "text" + }, + { + "bbox": [ + 310, + 425, + 340, + 435 + ], + "score": 0.9, + "content": "B = 3", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 425, + 506, + 438 + ], + "score": 1.0, + "content": "is sufficient for all the experiments. We", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 436, + 369, + 449 + ], + "spans": [ + { + "bbox": [ + 106, + 436, + 286, + 449 + ], + "score": 1.0, + "content": "pre-train the the behavior policy network for", + "type": "text" + }, + { + "bbox": [ + 286, + 436, + 308, + 447 + ], + "score": 0.26, + "content": "4 0 0 \\mathrm { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 436, + 369, + 449 + ], + "score": 1.0, + "content": "gradient steps.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 348, + 506, + 449 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 459, + 505, + 504 + ], + "lines": [ + { + "bbox": [ + 107, + 460, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 107, + 462, + 114, + 469 + ], + "score": 0.69, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 115, + 460, + 179, + 471 + ], + "score": 1.0, + "content": "network The", + "type": "text" + }, + { + "bbox": [ + 179, + 461, + 187, + 469 + ], + "score": 0.77, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 460, + 505, + 471 + ], + "score": 1.0, + "content": "network takes in a state and outputs the Lagrange multiplier for the state. The", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 470, + 505, + 482 + ], + "spans": [ + { + "bbox": [ + 106, + 470, + 184, + 482 + ], + "score": 1.0, + "content": "architecture of the", + "type": "text" + }, + { + "bbox": [ + 185, + 473, + 192, + 480 + ], + "score": 0.73, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 193, + 470, + 505, + 482 + ], + "score": 1.0, + "content": "network is a 3-layer feed-forward neural network with relu (Agarap, 2018)", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 482, + 505, + 493 + ], + "spans": [ + { + "bbox": [ + 106, + 482, + 505, + 493 + ], + "score": 1.0, + "content": "activation. The size of each hidden layer is 256. We use softplus activation after the output to", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 493, + 258, + 505 + ], + "spans": [ + { + "bbox": [ + 106, + 493, + 258, + 505 + ], + "score": 1.0, + "content": "ensure that all the values are positive.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5, + "bbox_fs": [ + 106, + 460, + 505, + 505 + ] + }, + { + "type": "table", + "bbox": [ + 188, + 526, + 423, + 669 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 236, + 515, + 375, + 525 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 235, + 513, + 376, + 529 + ], + "spans": [ + { + "bbox": [ + 235, + 513, + 376, + 529 + ], + "score": 1.0, + "content": "Table 4: Default hyper-parameters", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "table_body", + "bbox": [ + 188, + 526, + 423, + 669 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 188, + 526, + 423, + 669 + ], + "spans": [ + { + "bbox": [ + 188, + 526, + 423, + 669 + ], + "score": 0.982, + "html": "
Hyper-parameterValue (Gym/Adroit)
OptimizerAdam (Kingma & Ba,2015)
Policy learning rate5e-6/5e-8
Q network learning rate3e-4
α learning ratele-5/1e-7
batch size100
Target update rate T1e-3
Discount factor y0.99
Initial β10
β learning rate1e-3
Steps per epoch T2000
Number of epochs500
", + "type": "table", + "image_path": "30e2d602098560b912248512e1bd878e2d277cf0ae8755ec1d886c59e55e2dc9.jpg" + } + ] + } + ], + "index": 38, + "virtual_lines": [ + { + "bbox": [ + 188, + 526, + 423, + 539.0 + ], + "spans": [], + "index": 33 + }, + { + "bbox": [ + 188, + 539.0, + 423, + 552.0 + ], + "spans": [], + "index": 34 + }, + { + "bbox": [ + 188, + 552.0, + 423, + 565.0 + ], + "spans": [], + "index": 35 + }, + { + "bbox": [ + 188, + 565.0, + 423, + 578.0 + ], + "spans": [], + "index": 36 + }, + { + "bbox": [ + 188, + 578.0, + 423, + 591.0 + ], + "spans": [], + "index": 37 + }, + { + "bbox": [ + 188, + 591.0, + 423, + 604.0 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 188, + 604.0, + 423, + 617.0 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 188, + 617.0, + 423, + 630.0 + ], + "spans": [], + "index": 40 + }, + { + "bbox": [ + 188, + 630.0, + 423, + 643.0 + ], + "spans": [], + "index": 41 + }, + { + "bbox": [ + 188, + 643.0, + 423, + 656.0 + ], + "spans": [], + "index": 42 + }, + { + "bbox": [ + 188, + 656.0, + 423, + 669.0 + ], + "spans": [], + "index": 43 + } + ] + } + ], + "index": 35.0 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 142, + 189, + 469, + 357 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 177, + 176, + 434, + 188 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 176, + 173, + 434, + 191 + ], + "spans": [ + { + "bbox": [ + 176, + 173, + 434, + 191 + ], + "score": 1.0, + "content": "Table 5: Task-specific hyper-parameters for OpenAI gym tasks.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 142, + 189, + 469, + 357 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 142, + 189, + 469, + 357 + ], + "spans": [ + { + "bbox": [ + 142, + 189, + 469, + 357 + ], + "score": 0.984, + "html": "
Task nameKL divergence threshold ∈kLMaximum entropy Ho
halfcheetah-rand9-3
walker2d-rand0.16
hopper-rand3-3
halfcheetah-med4-12
walker2d-med2.1-9
hopper-med2.4-6
halfcheetah-med-exp11.5-24
walker2d-med-exp5-12
hopper-med-exp2.6-6
halfcheetah-mixed6-12
walker2d-mixed4-6
hopper-mixed3-3
", + "type": "table", + "image_path": "a9193ce34de28d21bafa57d2c16f08ba15ae8f86857b3267c2c216a6055f1e32.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 142, + 189, + 469, + 245.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 142, + 245.0, + 469, + 301.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 142, + 301.0, + 469, + 357.0 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "table", + "bbox": [ + 166, + 568, + 444, + 634 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 134, + 556, + 475, + 567 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 133, + 555, + 477, + 568 + ], + "spans": [ + { + "bbox": [ + 133, + 555, + 477, + 568 + ], + "score": 1.0, + "content": "Table 6: Task-specific hyper-parameters for Adroit tasks with human demonstrations.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "table_body", + "bbox": [ + 166, + 568, + 444, + 634 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 166, + 568, + 444, + 634 + ], + "spans": [ + { + "bbox": [ + 166, + 568, + 444, + 634 + ], + "score": 0.977, + "html": "
Task nameMMD threshold ∈MMDMinimum entropy Ho
pen-human0.06-200
hammer-human0.1-60
door-human0.1-60
relocate-human0.1-60
", + "type": "table", + "image_path": "49f3d5ca4c68fe2386652ebfed83eb4eca06bb2baeb7e7002cdfaf728de56f80.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 166, + 568, + 444, + 590.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 166, + 590.0, + 444, + 612.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 166, + 612.0, + 444, + 634.0 + ], + "spans": [], + "index": 7 + } + ] + } + ], + "index": 5.0 + } + ], + "page_idx": 17, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 763 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 763 + ], + "score": 1.0, + "content": "18", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 106, + 27, + 307, + 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 2021", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 142, + 189, + 469, + 357 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 177, + 176, + 434, + 188 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 176, + 173, + 434, + 191 + ], + "spans": [ + { + "bbox": [ + 176, + 173, + 434, + 191 + ], + "score": 1.0, + "content": "Table 5: Task-specific hyper-parameters for OpenAI gym tasks.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 142, + 189, + 469, + 357 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 142, + 189, + 469, + 357 + ], + "spans": [ + { + "bbox": [ + 142, + 189, + 469, + 357 + ], + "score": 0.984, + "html": "
Task nameKL divergence threshold ∈kLMaximum entropy Ho
halfcheetah-rand9-3
walker2d-rand0.16
hopper-rand3-3
halfcheetah-med4-12
walker2d-med2.1-9
hopper-med2.4-6
halfcheetah-med-exp11.5-24
walker2d-med-exp5-12
hopper-med-exp2.6-6
halfcheetah-mixed6-12
walker2d-mixed4-6
hopper-mixed3-3
", + "type": "table", + "image_path": "a9193ce34de28d21bafa57d2c16f08ba15ae8f86857b3267c2c216a6055f1e32.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 142, + 189, + 469, + 245.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 142, + 245.0, + 469, + 301.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 142, + 301.0, + 469, + 357.0 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "table", + "bbox": [ + 166, + 568, + 444, + 634 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 134, + 556, + 475, + 567 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 133, + 555, + 477, + 568 + ], + "spans": [ + { + "bbox": [ + 133, + 555, + 477, + 568 + ], + "score": 1.0, + "content": "Table 6: Task-specific hyper-parameters for Adroit tasks with human demonstrations.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "table_body", + "bbox": [ + 166, + 568, + 444, + 634 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 166, + 568, + 444, + 634 + ], + "spans": [ + { + "bbox": [ + 166, + 568, + 444, + 634 + ], + "score": 0.977, + "html": "
Task nameMMD threshold ∈MMDMinimum entropy Ho
pen-human0.06-200
hammer-human0.1-60
door-human0.1-60
relocate-human0.1-60
", + "type": "table", + "image_path": "49f3d5ca4c68fe2386652ebfed83eb4eca06bb2baeb7e7002cdfaf728de56f80.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 166, + 568, + 444, + 590.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 166, + 590.0, + 444, + 612.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 166, + 612.0, + 444, + 634.0 + ], + "spans": [], + "index": 7 + } + ] + } + ], + "index": 5.0 + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file