diff --git "a/parse/train/eaAM_bdW0Q/eaAM_bdW0Q_middle.json" "b/parse/train/eaAM_bdW0Q/eaAM_bdW0Q_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/eaAM_bdW0Q/eaAM_bdW0Q_middle.json" @@ -0,0 +1,33627 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 165, + 97, + 446, + 137 + ], + "lines": [ + { + "bbox": [ + 164, + 96, + 448, + 119 + ], + "spans": [ + { + "bbox": [ + 164, + 96, + 448, + 119 + ], + "score": 1.0, + "content": "Robust Deep Reinforcement Learning", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 209, + 117, + 402, + 136 + ], + "spans": [ + { + "bbox": [ + 209, + 117, + 402, + 136 + ], + "score": 1.0, + "content": "through Adversarial Loss", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 128, + 179, + 212, + 202 + ], + "lines": [ + { + "bbox": [ + 127, + 179, + 213, + 191 + ], + "spans": [ + { + "bbox": [ + 127, + 179, + 213, + 191 + ], + "score": 1.0, + "content": "Tuomas Oikarinen∗", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 127, + 190, + 209, + 203 + ], + "spans": [ + { + "bbox": [ + 127, + 190, + 209, + 203 + ], + "score": 1.0, + "content": "UC San Diego CSE", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.0 + }, + { + "type": "text", + "bbox": [ + 233, + 180, + 290, + 201 + ], + "lines": [ + { + "bbox": [ + 232, + 178, + 291, + 193 + ], + "spans": [ + { + "bbox": [ + 232, + 178, + 291, + 193 + ], + "score": 1.0, + "content": "Wang Zhang", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 234, + 189, + 289, + 202 + ], + "spans": [ + { + "bbox": [ + 234, + 189, + 289, + 202 + ], + "score": 1.0, + "content": "MIT MechE", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.0 + }, + { + "type": "text", + "bbox": [ + 315, + 180, + 405, + 201 + ], + "lines": [ + { + "bbox": [ + 314, + 179, + 407, + 191 + ], + "spans": [ + { + "bbox": [ + 314, + 179, + 407, + 191 + ], + "score": 1.0, + "content": "Alexandre Megretski", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 335, + 189, + 385, + 202 + ], + "spans": [ + { + "bbox": [ + 335, + 189, + 385, + 202 + ], + "score": 1.0, + "content": "MIT EECS", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 263, + 218, + 347, + 241 + ], + "lines": [ + { + "bbox": [ + 271, + 216, + 341, + 232 + ], + "spans": [ + { + "bbox": [ + 271, + 216, + 341, + 232 + ], + "score": 1.0, + "content": "Tsui-Wei Weng", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 261, + 228, + 349, + 243 + ], + "spans": [ + { + "bbox": [ + 261, + 228, + 349, + 243 + ], + "score": 1.0, + "content": "UC San Diego HDSI", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5 + }, + { + "type": "title", + "bbox": [ + 283, + 269, + 328, + 282 + ], + "lines": [ + { + "bbox": [ + 282, + 269, + 330, + 283 + ], + "spans": [ + { + "bbox": [ + 282, + 269, + 330, + 283 + ], + "score": 1.0, + "content": "Abstract", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 143, + 297, + 469, + 471 + ], + "lines": [ + { + "bbox": [ + 142, + 297, + 469, + 309 + ], + "spans": [ + { + "bbox": [ + 142, + 297, + 469, + 309 + ], + "score": 1.0, + "content": "Recent studies have shown that deep reinforcement learning agents are vulnerable", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 308, + 470, + 321 + ], + "spans": [ + { + "bbox": [ + 141, + 308, + 470, + 321 + ], + "score": 1.0, + "content": "to small adversarial perturbations on the agent’s inputs, which raises concerns", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 142, + 319, + 469, + 331 + ], + "spans": [ + { + "bbox": [ + 142, + 319, + 469, + 331 + ], + "score": 1.0, + "content": "about deploying such agents in the real world. To address this issue, we propose", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 329, + 470, + 342 + ], + "spans": [ + { + "bbox": [ + 141, + 329, + 470, + 342 + ], + "score": 1.0, + "content": "RADIAL-RL, a principled framework to train reinforcement learning agents with", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 341, + 470, + 353 + ], + "spans": [ + { + "bbox": [ + 141, + 341, + 262, + 353 + ], + "score": 1.0, + "content": "improved robustness against", + "type": "text" + }, + { + "bbox": [ + 263, + 341, + 271, + 353 + ], + "score": 0.87, + "content": "l _ { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 272, + 341, + 470, + 353 + ], + "score": 1.0, + "content": "-norm bounded adversarial attacks. Our frame-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 352, + 470, + 364 + ], + "spans": [ + { + "bbox": [ + 141, + 352, + 470, + 364 + ], + "score": 1.0, + "content": "work is compatible with popular deep reinforcement learning algorithms and we", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 142, + 362, + 470, + 375 + ], + "spans": [ + { + "bbox": [ + 142, + 362, + 470, + 375 + ], + "score": 1.0, + "content": "demonstrate its performance with deep Q-learning, A3C and PPO. We experi-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 373, + 469, + 385 + ], + "spans": [ + { + "bbox": [ + 141, + 373, + 469, + 385 + ], + "score": 1.0, + "content": "ment on three deep RL benchmarks (Atari, MuJoCo and ProcGen) to show the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 142, + 385, + 470, + 396 + ], + "spans": [ + { + "bbox": [ + 142, + 385, + 470, + 396 + ], + "score": 1.0, + "content": "effectiveness of our robust training algorithm. Our RADIAL-RL agents consis-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 395, + 470, + 408 + ], + "spans": [ + { + "bbox": [ + 141, + 395, + 470, + 408 + ], + "score": 1.0, + "content": "tently outperform prior methods when tested against attacks of varying strength", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 141, + 406, + 470, + 419 + ], + "spans": [ + { + "bbox": [ + 141, + 406, + 470, + 419 + ], + "score": 1.0, + "content": "and are more computationally efficient to train. In addition, we propose a new", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 417, + 470, + 429 + ], + "spans": [ + { + "bbox": [ + 141, + 417, + 470, + 429 + ], + "score": 1.0, + "content": "evaluation method called Greedy Worst-Case Reward (GWC) to measure attack", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 141, + 428, + 470, + 439 + ], + "spans": [ + { + "bbox": [ + 141, + 428, + 470, + 439 + ], + "score": 1.0, + "content": "agnostic robustness of deep RL agents. We show that GWC can be evaluated", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 142, + 439, + 470, + 451 + ], + "spans": [ + { + "bbox": [ + 142, + 439, + 470, + 451 + ], + "score": 1.0, + "content": "efficiently and is a good estimate of the reward under the worst possible se-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 141, + 450, + 470, + 462 + ], + "spans": [ + { + "bbox": [ + 141, + 450, + 470, + 462 + ], + "score": 1.0, + "content": "quence of adversarial attacks. All code used for our experiments is available", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 141, + 461, + 390, + 473 + ], + "spans": [ + { + "bbox": [ + 141, + 461, + 390, + 473 + ], + "score": 1.0, + "content": "at https://github.com/tuomaso/radial_rl_v2.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 18.5 + }, + { + "type": "title", + "bbox": [ + 107, + 498, + 190, + 512 + ], + "lines": [ + { + "bbox": [ + 104, + 497, + 192, + 514 + ], + "spans": [ + { + "bbox": [ + 104, + 497, + 192, + 514 + ], + "score": 1.0, + "content": "1 Introduction", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 525, + 505, + 636 + ], + "lines": [ + { + "bbox": [ + 106, + 527, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 106, + 527, + 505, + 538 + ], + "score": 1.0, + "content": "Deep learning has achieved enormous success on a variety of challenging domains, ranging from", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 538, + 506, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 506, + 549 + ], + "score": 1.0, + "content": "computer vision [1], natural language processing [2] to reinforcement learning (RL) [3, 4]. Neverthe-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 547, + 506, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 506, + 560 + ], + "score": 1.0, + "content": "less, the existence of adversarial examples [5] indicates that deep neural networks (DNNs) are not", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 558, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 505, + 572 + ], + "score": 1.0, + "content": "as robust and trustworthy as we would expect, as small and often imperceptible perturbations can", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 570, + 505, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 570, + 505, + 582 + ], + "score": 1.0, + "content": "result in misclassifications of state-of-the-art DNNs. Unfortunately, adversarial attacks have also been", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 581, + 506, + 594 + ], + "spans": [ + { + "bbox": [ + 106, + 581, + 506, + 594 + ], + "score": 1.0, + "content": "shown possible in deep reinforcement learning, where adversarial perturbations in the observation", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 591, + 506, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 506, + 605 + ], + "score": 1.0, + "content": "space and/or action space can cause arbitrarily bad performance of deep RL agents [6, 7, 8]. As deep", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 603, + 506, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 603, + 506, + 615 + ], + "score": 1.0, + "content": "RL agents are deployed in many safety critical applications such as self-driving cars and robotics, it", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 613, + 506, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 506, + 626 + ], + "score": 1.0, + "content": "is of crucial importance to develop robust training algorithms (a.k.a. defense algorithms) such that", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 624, + 477, + 637 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 477, + 637 + ], + "score": 1.0, + "content": "the resulting trained agents are robust against adversarial (and non-adversarial) perturbation.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 107, + 640, + 505, + 685 + ], + "lines": [ + { + "bbox": [ + 106, + 641, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 505, + 653 + ], + "score": 1.0, + "content": "Many heuristic defenses have been proposed to improve robustness of DNNs against adversarial", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 651, + 507, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 507, + 664 + ], + "score": 1.0, + "content": "attacks for image classification tasks, but they often fail against stronger adversarial attack algorithms.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 663, + 506, + 675 + ], + "spans": [ + { + "bbox": [ + 106, + 663, + 506, + 675 + ], + "score": 1.0, + "content": "For example, [9] showed that 13 such defense methods (recently published at prestigious conferences)", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 674, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 106, + 674, + 505, + 685 + ], + "score": 1.0, + "content": "can all be broken by more advanced attacks. One emerging alternative to heuristic defenses is", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 39.5 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 118, + 699, + 338, + 709 + ], + "lines": [ + { + "bbox": [ + 119, + 698, + 338, + 711 + ], + "spans": [ + { + "bbox": [ + 119, + 698, + 338, + 711 + ], + "score": 1.0, + "content": "∗correspondence to: toikarinen@ucsd.edu, lweng@ucsd.edu", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 731, + 385, + 742 + ], + "lines": [ + { + "bbox": [ + 106, + 730, + 386, + 743 + ], + "spans": [ + { + "bbox": [ + 106, + 730, + 386, + 743 + ], + "score": 1.0, + "content": "35th Conference on Neural Information Processing Systems (NeurIPS 2021).", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 430, + 179, + 484, + 201 + ], + "lines": [ + { + "bbox": [ + 429, + 178, + 485, + 191 + ], + "spans": [ + { + "bbox": [ + 429, + 178, + 485, + 191 + ], + "score": 1.0, + "content": "Luca Daniel", + "type": "text" + } + ] + }, + { + "bbox": [ + 432, + 190, + 482, + 202 + ], + "spans": [ + { + "bbox": [ + 432, + 190, + 482, + 202 + ], + "score": 1.0, + "content": "MIT EECS", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 165, + 97, + 446, + 137 + ], + "lines": [ + { + "bbox": [ + 164, + 96, + 448, + 119 + ], + "spans": [ + { + "bbox": [ + 164, + 96, + 448, + 119 + ], + "score": 1.0, + "content": "Robust Deep Reinforcement Learning", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 209, + 117, + 402, + 136 + ], + "spans": [ + { + "bbox": [ + 209, + 117, + 402, + 136 + ], + "score": 1.0, + "content": "through Adversarial Loss", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 128, + 179, + 212, + 202 + ], + "lines": [ + { + "bbox": [ + 127, + 179, + 213, + 191 + ], + "spans": [ + { + "bbox": [ + 127, + 179, + 213, + 191 + ], + "score": 1.0, + "content": "Tuomas Oikarinen∗", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 127, + 190, + 209, + 203 + ], + "spans": [ + { + "bbox": [ + 127, + 190, + 209, + 203 + ], + "score": 1.0, + "content": "UC San Diego CSE", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.0, + "bbox_fs": [ + 127, + 179, + 213, + 203 + ] + }, + { + "type": "text", + "bbox": [ + 233, + 180, + 290, + 201 + ], + "lines": [ + { + "bbox": [ + 232, + 178, + 291, + 193 + ], + "spans": [ + { + "bbox": [ + 232, + 178, + 291, + 193 + ], + "score": 1.0, + "content": "Wang Zhang", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 234, + 189, + 289, + 202 + ], + "spans": [ + { + "bbox": [ + 234, + 189, + 289, + 202 + ], + "score": 1.0, + "content": "MIT MechE", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.0, + "bbox_fs": [ + 232, + 178, + 291, + 202 + ] + }, + { + "type": "text", + "bbox": [ + 315, + 180, + 405, + 201 + ], + "lines": [ + { + "bbox": [ + 314, + 179, + 407, + 191 + ], + "spans": [ + { + "bbox": [ + 314, + 179, + 407, + 191 + ], + "score": 1.0, + "content": "Alexandre Megretski", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 335, + 189, + 385, + 202 + ], + "spans": [ + { + "bbox": [ + 335, + 189, + 385, + 202 + ], + "score": 1.0, + "content": "MIT EECS", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5.5, + "bbox_fs": [ + 314, + 179, + 407, + 202 + ] + }, + { + "type": "text", + "bbox": [ + 263, + 218, + 347, + 241 + ], + "lines": [ + { + "bbox": [ + 271, + 216, + 341, + 232 + ], + "spans": [ + { + "bbox": [ + 271, + 216, + 341, + 232 + ], + "score": 1.0, + "content": "Tsui-Wei Weng", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 261, + 228, + 349, + 243 + ], + "spans": [ + { + "bbox": [ + 261, + 228, + 349, + 243 + ], + "score": 1.0, + "content": "UC San Diego HDSI", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5, + "bbox_fs": [ + 261, + 216, + 349, + 243 + ] + }, + { + "type": "title", + "bbox": [ + 283, + 269, + 328, + 282 + ], + "lines": [ + { + "bbox": [ + 282, + 269, + 330, + 283 + ], + "spans": [ + { + "bbox": [ + 282, + 269, + 330, + 283 + ], + "score": 1.0, + "content": "Abstract", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 143, + 297, + 469, + 471 + ], + "lines": [ + { + "bbox": [ + 142, + 297, + 469, + 309 + ], + "spans": [ + { + "bbox": [ + 142, + 297, + 469, + 309 + ], + "score": 1.0, + "content": "Recent studies have shown that deep reinforcement learning agents are vulnerable", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 308, + 470, + 321 + ], + "spans": [ + { + "bbox": [ + 141, + 308, + 470, + 321 + ], + "score": 1.0, + "content": "to small adversarial perturbations on the agent’s inputs, which raises concerns", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 142, + 319, + 469, + 331 + ], + "spans": [ + { + "bbox": [ + 142, + 319, + 469, + 331 + ], + "score": 1.0, + "content": "about deploying such agents in the real world. To address this issue, we propose", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 329, + 470, + 342 + ], + "spans": [ + { + "bbox": [ + 141, + 329, + 470, + 342 + ], + "score": 1.0, + "content": "RADIAL-RL, a principled framework to train reinforcement learning agents with", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 341, + 470, + 353 + ], + "spans": [ + { + "bbox": [ + 141, + 341, + 262, + 353 + ], + "score": 1.0, + "content": "improved robustness against", + "type": "text" + }, + { + "bbox": [ + 263, + 341, + 271, + 353 + ], + "score": 0.87, + "content": "l _ { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 272, + 341, + 470, + 353 + ], + "score": 1.0, + "content": "-norm bounded adversarial attacks. Our frame-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 352, + 470, + 364 + ], + "spans": [ + { + "bbox": [ + 141, + 352, + 470, + 364 + ], + "score": 1.0, + "content": "work is compatible with popular deep reinforcement learning algorithms and we", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 142, + 362, + 470, + 375 + ], + "spans": [ + { + "bbox": [ + 142, + 362, + 470, + 375 + ], + "score": 1.0, + "content": "demonstrate its performance with deep Q-learning, A3C and PPO. We experi-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 373, + 469, + 385 + ], + "spans": [ + { + "bbox": [ + 141, + 373, + 469, + 385 + ], + "score": 1.0, + "content": "ment on three deep RL benchmarks (Atari, MuJoCo and ProcGen) to show the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 142, + 385, + 470, + 396 + ], + "spans": [ + { + "bbox": [ + 142, + 385, + 470, + 396 + ], + "score": 1.0, + "content": "effectiveness of our robust training algorithm. Our RADIAL-RL agents consis-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 395, + 470, + 408 + ], + "spans": [ + { + "bbox": [ + 141, + 395, + 470, + 408 + ], + "score": 1.0, + "content": "tently outperform prior methods when tested against attacks of varying strength", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 141, + 406, + 470, + 419 + ], + "spans": [ + { + "bbox": [ + 141, + 406, + 470, + 419 + ], + "score": 1.0, + "content": "and are more computationally efficient to train. In addition, we propose a new", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 417, + 470, + 429 + ], + "spans": [ + { + "bbox": [ + 141, + 417, + 470, + 429 + ], + "score": 1.0, + "content": "evaluation method called Greedy Worst-Case Reward (GWC) to measure attack", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 141, + 428, + 470, + 439 + ], + "spans": [ + { + "bbox": [ + 141, + 428, + 470, + 439 + ], + "score": 1.0, + "content": "agnostic robustness of deep RL agents. We show that GWC can be evaluated", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 142, + 439, + 470, + 451 + ], + "spans": [ + { + "bbox": [ + 142, + 439, + 470, + 451 + ], + "score": 1.0, + "content": "efficiently and is a good estimate of the reward under the worst possible se-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 141, + 450, + 470, + 462 + ], + "spans": [ + { + "bbox": [ + 141, + 450, + 470, + 462 + ], + "score": 1.0, + "content": "quence of adversarial attacks. All code used for our experiments is available", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 141, + 461, + 390, + 473 + ], + "spans": [ + { + "bbox": [ + 141, + 461, + 390, + 473 + ], + "score": 1.0, + "content": "at https://github.com/tuomaso/radial_rl_v2.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 18.5, + "bbox_fs": [ + 141, + 297, + 470, + 473 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 498, + 190, + 512 + ], + "lines": [ + { + "bbox": [ + 104, + 497, + 192, + 514 + ], + "spans": [ + { + "bbox": [ + 104, + 497, + 192, + 514 + ], + "score": 1.0, + "content": "1 Introduction", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 525, + 505, + 636 + ], + "lines": [ + { + "bbox": [ + 106, + 527, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 106, + 527, + 505, + 538 + ], + "score": 1.0, + "content": "Deep learning has achieved enormous success on a variety of challenging domains, ranging from", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 538, + 506, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 506, + 549 + ], + "score": 1.0, + "content": "computer vision [1], natural language processing [2] to reinforcement learning (RL) [3, 4]. Neverthe-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 547, + 506, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 506, + 560 + ], + "score": 1.0, + "content": "less, the existence of adversarial examples [5] indicates that deep neural networks (DNNs) are not", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 558, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 505, + 572 + ], + "score": 1.0, + "content": "as robust and trustworthy as we would expect, as small and often imperceptible perturbations can", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 570, + 505, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 570, + 505, + 582 + ], + "score": 1.0, + "content": "result in misclassifications of state-of-the-art DNNs. Unfortunately, adversarial attacks have also been", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 581, + 506, + 594 + ], + "spans": [ + { + "bbox": [ + 106, + 581, + 506, + 594 + ], + "score": 1.0, + "content": "shown possible in deep reinforcement learning, where adversarial perturbations in the observation", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 591, + 506, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 506, + 605 + ], + "score": 1.0, + "content": "space and/or action space can cause arbitrarily bad performance of deep RL agents [6, 7, 8]. As deep", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 603, + 506, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 603, + 506, + 615 + ], + "score": 1.0, + "content": "RL agents are deployed in many safety critical applications such as self-driving cars and robotics, it", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 613, + 506, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 506, + 626 + ], + "score": 1.0, + "content": "is of crucial importance to develop robust training algorithms (a.k.a. defense algorithms) such that", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 624, + 477, + 637 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 477, + 637 + ], + "score": 1.0, + "content": "the resulting trained agents are robust against adversarial (and non-adversarial) perturbation.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 527, + 506, + 637 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 640, + 505, + 685 + ], + "lines": [ + { + "bbox": [ + 106, + 641, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 505, + 653 + ], + "score": 1.0, + "content": "Many heuristic defenses have been proposed to improve robustness of DNNs against adversarial", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 651, + 507, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 507, + 664 + ], + "score": 1.0, + "content": "attacks for image classification tasks, but they often fail against stronger adversarial attack algorithms.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 663, + 506, + 675 + ], + "spans": [ + { + "bbox": [ + 106, + 663, + 506, + 675 + ], + "score": 1.0, + "content": "For example, [9] showed that 13 such defense methods (recently published at prestigious conferences)", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 674, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 106, + 674, + 505, + 685 + ], + "score": 1.0, + "content": "can all be broken by more advanced attacks. One emerging alternative to heuristic defenses is", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 318, + 506, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 506, + 332 + ], + "score": 1.0, + "content": "defense algorithms 2 based on robustness verification or certification bounds [10, 11, 12, 13]. These", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 329, + 506, + 344 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 492, + 344 + ], + "score": 1.0, + "content": "algorithms produce robustness certificates such that for any perturbations within the specified", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 492, + 330, + 502, + 343 + ], + "score": 0.83, + "content": "\\ell _ { p }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 502, + 329, + 506, + 344 + ], + "score": 1.0, + "content": "-", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 340, + 506, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 506, + 354 + ], + "score": 1.0, + "content": "norm distance \u000f, the trained DNN will produce consistent classification results on given data points.", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 352, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 106, + 352, + 505, + 364 + ], + "score": 1.0, + "content": "Representative works along this line include [11] and [14], where the learned models can have much", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 362, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 505, + 375 + ], + "score": 1.0, + "content": "higher certified accuracies by including the robustness verification bounds in the loss function with", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 374, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 505, + 386 + ], + "score": 1.0, + "content": "proper training schedule, even if the verifier produces loose robustness certificates [14] for models", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 385, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 106, + 385, + 505, + 397 + ], + "score": 1.0, + "content": "without robust training (a.k.a. nominal models). Here, the certified accuracy is calculated as the", + "type": "text", + "cross_page": true + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 395, + 506, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 506, + 409 + ], + "score": 1.0, + "content": "percentage of the test images that are guaranteed to be classified correctly under a given perturbation", + "type": "text", + "cross_page": true + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 406, + 161, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 406, + 151, + 420 + ], + "score": 1.0, + "content": "magnitude", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 151, + 409, + 156, + 416 + ], + "score": 0.39, + "content": "\\epsilon", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 157, + 406, + 161, + 420 + ], + "score": 1.0, + "content": ".", + "type": "text", + "cross_page": true + } + ], + "index": 13 + } + ], + "index": 39.5, + "bbox_fs": [ + 105, + 641, + 507, + 685 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 147, + 69, + 461, + 247 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 147, + 69, + 461, + 247 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 147, + 69, + 461, + 247 + ], + "spans": [ + { + "bbox": [ + 147, + 69, + 461, + 247 + ], + "score": 0.969, + "type": "image", + "image_path": "86b2ea5b9ea7c8293bf47f1b10bcb3a6edaa515344f97c86d3c6f1edfeed1a94.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 147, + 69, + 461, + 128.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 147, + 128.33333333333334, + 461, + 187.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 147, + 187.66666666666669, + 461, + 247.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 254, + 505, + 277 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 254, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 106, + 254, + 505, + 267 + ], + "score": 1.0, + "content": "Figure 1: Screenshots of our RADIAL framework promoting robustness of deep RL agents while", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 265, + 464, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 464, + 277 + ], + "score": 1.0, + "content": "the standard deep RL agents without robust training are vulnerable to adversarial attacks.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 107, + 318, + 505, + 417 + ], + "lines": [ + { + "bbox": [ + 105, + 318, + 506, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 506, + 332 + ], + "score": 1.0, + "content": "defense algorithms 2 based on robustness verification or certification bounds [10, 11, 12, 13]. These", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 329, + 506, + 344 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 492, + 344 + ], + "score": 1.0, + "content": "algorithms produce robustness certificates such that for any perturbations within the specified", + "type": "text" + }, + { + "bbox": [ + 492, + 330, + 502, + 343 + ], + "score": 0.83, + "content": "\\ell _ { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 329, + 506, + 344 + ], + "score": 1.0, + "content": "-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 340, + 506, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 506, + 354 + ], + "score": 1.0, + "content": "norm distance \u000f, the trained DNN will produce consistent classification results on given data points.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 352, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 106, + 352, + 505, + 364 + ], + "score": 1.0, + "content": "Representative works along this line include [11] and [14], where the learned models can have much", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 362, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 505, + 375 + ], + "score": 1.0, + "content": "higher certified accuracies by including the robustness verification bounds in the loss function with", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 374, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 505, + 386 + ], + "score": 1.0, + "content": "proper training schedule, even if the verifier produces loose robustness certificates [14] for models", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 385, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 106, + 385, + 505, + 397 + ], + "score": 1.0, + "content": "without robust training (a.k.a. nominal models). Here, the certified accuracy is calculated as the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 395, + 506, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 506, + 409 + ], + "score": 1.0, + "content": "percentage of the test images that are guaranteed to be classified correctly under a given perturbation", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 406, + 161, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 406, + 151, + 420 + ], + "score": 1.0, + "content": "magnitude", + "type": "text" + }, + { + "bbox": [ + 151, + 409, + 156, + 416 + ], + "score": 0.39, + "content": "\\epsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 406, + 161, + 420 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 106, + 423, + 505, + 499 + ], + "lines": [ + { + "bbox": [ + 105, + 421, + 506, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 506, + 436 + ], + "score": 1.0, + "content": "However, most of the defense algorithms are developed for classification tasks. Few defense algo-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 434, + 506, + 446 + ], + "spans": [ + { + "bbox": [ + 106, + 434, + 506, + 446 + ], + "score": 1.0, + "content": "rithms have been designed for deep RL agents perhaps due to the additional challenges in RL that are", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 445, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 445, + 505, + 457 + ], + "score": 1.0, + "content": "not present in classification tasks, including credit assignment and lack of a stationary training set. To", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 455, + 506, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 506, + 469 + ], + "score": 1.0, + "content": "bridge this gap, in this paper we present the RADIAL(Robust ADversarIAl Loss)-RL framework to", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 466, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 505, + 478 + ], + "score": 1.0, + "content": "train robust deep RL agents. We show that RADIAL can improve the robustness of deep RL agents", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 477, + 506, + 490 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 506, + 490 + ], + "score": 1.0, + "content": "by using carefully designed adversarial loss functions based on robustness verification bounds. Our", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 489, + 229, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 229, + 500 + ], + "score": 1.0, + "content": "contributions are listed below:", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 133, + 506, + 505, + 651 + ], + "lines": [ + { + "bbox": [ + 132, + 505, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 132, + 505, + 506, + 519 + ], + "score": 1.0, + "content": "• We propose a novel robust deep RL framework, RADIAL-RL, which can be applied to", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 515, + 506, + 531 + ], + "spans": [ + { + "bbox": [ + 141, + 515, + 506, + 531 + ], + "score": 1.0, + "content": "different types of deep RL algorithms. We demonstrate RADIAL on three popular RL", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 141, + 528, + 329, + 540 + ], + "spans": [ + { + "bbox": [ + 141, + 528, + 329, + 540 + ], + "score": 1.0, + "content": "algorithms, DQN [3], A3C [15] and PPO [16].", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 138, + 538, + 506, + 553 + ], + "spans": [ + { + "bbox": [ + 138, + 538, + 506, + 553 + ], + "score": 1.0, + "content": "We demonstrate the superior performance of RADIAL agents on both Atari games and", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 141, + 551, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 141, + 551, + 346, + 563 + ], + "score": 1.0, + "content": "continuous control tasks in MuJoCo: our agents are", + "type": "text" + }, + { + "bbox": [ + 346, + 551, + 381, + 561 + ], + "score": 0.9, + "content": "2 - 1 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 551, + 505, + 563 + ], + "score": 1.0, + "content": "more computationally efficient", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 141, + 561, + 506, + 575 + ], + "spans": [ + { + "bbox": [ + 141, + 561, + 301, + 575 + ], + "score": 1.0, + "content": "to train than [17] and can resist up to", + "type": "text" + }, + { + "bbox": [ + 301, + 562, + 316, + 572 + ], + "score": 0.87, + "content": "5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 561, + 506, + 575 + ], + "score": 1.0, + "content": "stronger adversarial perturbations better than", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 141, + 573, + 239, + 585 + ], + "spans": [ + { + "bbox": [ + 141, + 573, + 239, + 585 + ], + "score": 1.0, + "content": "existing works [18, 17].", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 137, + 583, + 506, + 597 + ], + "spans": [ + { + "bbox": [ + 137, + 583, + 506, + 597 + ], + "score": 1.0, + "content": "• We also evaluate the effects of robust training on the ability of agents to generalize to new", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 141, + 595, + 505, + 608 + ], + "spans": [ + { + "bbox": [ + 141, + 595, + 505, + 608 + ], + "score": 1.0, + "content": "levels using the ProcGen benchmark, and show that our training also increases robustness", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 141, + 606, + 456, + 618 + ], + "spans": [ + { + "bbox": [ + 141, + 606, + 355, + 618 + ], + "score": 1.0, + "content": "on unseen levels, reaching high rewards even against", + "type": "text" + }, + { + "bbox": [ + 355, + 606, + 399, + 618 + ], + "score": 0.88, + "content": "\\epsilon = 5 / 2 5 5", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 606, + 456, + 618 + ], + "score": 1.0, + "content": "PGD-attacks.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 133, + 617, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 133, + 617, + 506, + 631 + ], + "score": 1.0, + "content": "• We propose a new evaluation method, Greedy Worst-Case Reward (GWC), for efficiently", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 141, + 628, + 507, + 642 + ], + "spans": [ + { + "bbox": [ + 141, + 628, + 507, + 642 + ], + "score": 1.0, + "content": "(in linear time) evaluating RL agent performance under attack of strongest adversaries (i.e.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 141, + 640, + 373, + 652 + ], + "spans": [ + { + "bbox": [ + 141, + 640, + 373, + 652 + ], + "score": 1.0, + "content": "worst-case perturbation) on discrete action environments.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 27 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 701, + 507, + 722 + ], + "lines": [ + { + "bbox": [ + 118, + 699, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 118, + 699, + 506, + 714 + ], + "score": 1.0, + "content": "2We don’t use the naming convention in this field to call this type of defense as certified defense because we", + "type": "text" + } + ] + }, + { + "bbox": [ + 106, + 712, + 461, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 712, + 461, + 723 + ], + "score": 1.0, + "content": "think it is misleading as such defense methodology cannot provide any certificates on unseen data.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 740, + 310, + 753 + ], + "spans": [ + { + "bbox": [ + 301, + 740, + 310, + 753 + ], + "score": 1.0, + "content": "2", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 147, + 69, + 461, + 247 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 147, + 69, + 461, + 247 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 147, + 69, + 461, + 247 + ], + "spans": [ + { + "bbox": [ + 147, + 69, + 461, + 247 + ], + "score": 0.969, + "type": "image", + "image_path": "86b2ea5b9ea7c8293bf47f1b10bcb3a6edaa515344f97c86d3c6f1edfeed1a94.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 147, + 69, + 461, + 128.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 147, + 128.33333333333334, + 461, + 187.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 147, + 187.66666666666669, + 461, + 247.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 254, + 505, + 277 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 254, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 106, + 254, + 505, + 267 + ], + "score": 1.0, + "content": "Figure 1: Screenshots of our RADIAL framework promoting robustness of deep RL agents while", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 265, + 464, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 464, + 277 + ], + "score": 1.0, + "content": "the standard deep RL agents without robust training are vulnerable to adversarial attacks.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 107, + 318, + 505, + 417 + ], + "lines": [], + "index": 9, + "bbox_fs": [ + 105, + 318, + 506, + 420 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 423, + 505, + 499 + ], + "lines": [ + { + "bbox": [ + 105, + 421, + 506, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 506, + 436 + ], + "score": 1.0, + "content": "However, most of the defense algorithms are developed for classification tasks. Few defense algo-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 434, + 506, + 446 + ], + "spans": [ + { + "bbox": [ + 106, + 434, + 506, + 446 + ], + "score": 1.0, + "content": "rithms have been designed for deep RL agents perhaps due to the additional challenges in RL that are", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 445, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 445, + 505, + 457 + ], + "score": 1.0, + "content": "not present in classification tasks, including credit assignment and lack of a stationary training set. To", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 455, + 506, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 506, + 469 + ], + "score": 1.0, + "content": "bridge this gap, in this paper we present the RADIAL(Robust ADversarIAl Loss)-RL framework to", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 466, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 505, + 478 + ], + "score": 1.0, + "content": "train robust deep RL agents. We show that RADIAL can improve the robustness of deep RL agents", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 477, + 506, + 490 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 506, + 490 + ], + "score": 1.0, + "content": "by using carefully designed adversarial loss functions based on robustness verification bounds. Our", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 489, + 229, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 229, + 500 + ], + "score": 1.0, + "content": "contributions are listed below:", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 421, + 506, + 500 + ] + }, + { + "type": "list", + "bbox": [ + 133, + 506, + 505, + 651 + ], + "lines": [ + { + "bbox": [ + 132, + 505, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 132, + 505, + 506, + 519 + ], + "score": 1.0, + "content": "• We propose a novel robust deep RL framework, RADIAL-RL, which can be applied to", + "type": "text" + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 515, + 506, + 531 + ], + "spans": [ + { + "bbox": [ + 141, + 515, + 506, + 531 + ], + "score": 1.0, + "content": "different types of deep RL algorithms. We demonstrate RADIAL on three popular RL", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 141, + 528, + 329, + 540 + ], + "spans": [ + { + "bbox": [ + 141, + 528, + 329, + 540 + ], + "score": 1.0, + "content": "algorithms, DQN [3], A3C [15] and PPO [16].", + "type": "text" + } + ], + "index": 23, + "is_list_end_line": true + }, + { + "bbox": [ + 138, + 538, + 506, + 553 + ], + "spans": [ + { + "bbox": [ + 138, + 538, + 506, + 553 + ], + "score": 1.0, + "content": "We demonstrate the superior performance of RADIAL agents on both Atari games and", + "type": "text" + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 551, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 141, + 551, + 346, + 563 + ], + "score": 1.0, + "content": "continuous control tasks in MuJoCo: our agents are", + "type": "text" + }, + { + "bbox": [ + 346, + 551, + 381, + 561 + ], + "score": 0.9, + "content": "2 - 1 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 551, + 505, + 563 + ], + "score": 1.0, + "content": "more computationally efficient", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 141, + 561, + 506, + 575 + ], + "spans": [ + { + "bbox": [ + 141, + 561, + 301, + 575 + ], + "score": 1.0, + "content": "to train than [17] and can resist up to", + "type": "text" + }, + { + "bbox": [ + 301, + 562, + 316, + 572 + ], + "score": 0.87, + "content": "5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 561, + 506, + 575 + ], + "score": 1.0, + "content": "stronger adversarial perturbations better than", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 141, + 573, + 239, + 585 + ], + "spans": [ + { + "bbox": [ + 141, + 573, + 239, + 585 + ], + "score": 1.0, + "content": "existing works [18, 17].", + "type": "text" + } + ], + "index": 27, + "is_list_end_line": true + }, + { + "bbox": [ + 137, + 583, + 506, + 597 + ], + "spans": [ + { + "bbox": [ + 137, + 583, + 506, + 597 + ], + "score": 1.0, + "content": "• We also evaluate the effects of robust training on the ability of agents to generalize to new", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 595, + 505, + 608 + ], + "spans": [ + { + "bbox": [ + 141, + 595, + 505, + 608 + ], + "score": 1.0, + "content": "levels using the ProcGen benchmark, and show that our training also increases robustness", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 141, + 606, + 456, + 618 + ], + "spans": [ + { + "bbox": [ + 141, + 606, + 355, + 618 + ], + "score": 1.0, + "content": "on unseen levels, reaching high rewards even against", + "type": "text" + }, + { + "bbox": [ + 355, + 606, + 399, + 618 + ], + "score": 0.88, + "content": "\\epsilon = 5 / 2 5 5", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 606, + 456, + 618 + ], + "score": 1.0, + "content": "PGD-attacks.", + "type": "text" + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 133, + 617, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 133, + 617, + 506, + 631 + ], + "score": 1.0, + "content": "• We propose a new evaluation method, Greedy Worst-Case Reward (GWC), for efficiently", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 628, + 507, + 642 + ], + "spans": [ + { + "bbox": [ + 141, + 628, + 507, + 642 + ], + "score": 1.0, + "content": "(in linear time) evaluating RL agent performance under attack of strongest adversaries (i.e.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 141, + 640, + 373, + 652 + ], + "spans": [ + { + "bbox": [ + 141, + 640, + 373, + 652 + ], + "score": 1.0, + "content": "worst-case perturbation) on discrete action environments.", + "type": "text" + } + ], + "index": 33, + "is_list_end_line": true + } + ], + "index": 27, + "bbox_fs": [ + 132, + 505, + 507, + 652 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 71, + 281, + 84 + ], + "lines": [ + { + "bbox": [ + 104, + 69, + 283, + 88 + ], + "spans": [ + { + "bbox": [ + 104, + 69, + 283, + 88 + ], + "score": 1.0, + "content": "2 Related work and background", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 107, + 96, + 264, + 108 + ], + "lines": [ + { + "bbox": [ + 105, + 95, + 266, + 109 + ], + "spans": [ + { + "bbox": [ + 105, + 95, + 266, + 109 + ], + "score": 1.0, + "content": "2.1 Adversarial attacks in Deep RL", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 106, + 116, + 506, + 182 + ], + "lines": [ + { + "bbox": [ + 106, + 116, + 505, + 129 + ], + "spans": [ + { + "bbox": [ + 106, + 116, + 505, + 129 + ], + "score": 1.0, + "content": "The topic of adversarial examples in supervised learning tasks has been extensively studied, especially", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 126, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 506, + 140 + ], + "score": 1.0, + "content": "for DNN classifiers [5, 19]. More recently, [6, 7, 8] showed that deep RL agents are also vulnerable to", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 137, + 506, + 151 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 506, + 151 + ], + "score": 1.0, + "content": "adversarial perturbations, including adversarial perturbations on agents’ observations and actions [6,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 150, + 506, + 161 + ], + "spans": [ + { + "bbox": [ + 106, + 150, + 506, + 161 + ], + "score": 1.0, + "content": "7, 8], mis-specification on the environment [20], adversarial disruptions on the agents [21] and other", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 160, + 506, + 172 + ], + "spans": [ + { + "bbox": [ + 105, + 160, + 506, + 172 + ], + "score": 1.0, + "content": "adversarial agents [22]. For a review of different attack and defense settings in RL see Ilahi et al.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 168, + 130, + 184 + ], + "spans": [ + { + "bbox": [ + 105, + 168, + 130, + 184 + ], + "score": 1.0, + "content": "[23].", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 107, + 187, + 505, + 243 + ], + "lines": [ + { + "bbox": [ + 105, + 186, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 219, + 200 + ], + "score": 1.0, + "content": "In this paper, we focus on", + "type": "text" + }, + { + "bbox": [ + 219, + 187, + 230, + 200 + ], + "score": 0.88, + "content": "\\ell _ { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 186, + 505, + 200 + ], + "score": 1.0, + "content": "-norm adversarial perturbations on agents’ observations since this", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 196, + 506, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 196, + 506, + 212 + ], + "score": 1.0, + "content": "threat model is adopted by many of the existing works investigating adversarial robustness of deep", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 208, + 506, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 208, + 417, + 222 + ], + "score": 1.0, + "content": "RL [6, 7, 8, 24, 25, 26, 27, 18, 17]. However, our framework is not limited to", + "type": "text" + }, + { + "bbox": [ + 417, + 209, + 427, + 221 + ], + "score": 0.88, + "content": "\\ell _ { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 208, + 506, + 222 + ], + "score": 1.0, + "content": "-norm perturbation", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 218, + 507, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 218, + 507, + 234 + ], + "score": 1.0, + "content": "and in fact can be easily extended to semantic perturbations (e.g. rotations, color/brightness changes,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 231, + 506, + 244 + ], + "spans": [ + { + "bbox": [ + 106, + 231, + 506, + 244 + ], + "score": 1.0, + "content": "etc) for vision-based deep RL agents (e.g. atari games) by leveraging the techniques proposed in [28].", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10 + }, + { + "type": "title", + "bbox": [ + 107, + 255, + 352, + 267 + ], + "lines": [ + { + "bbox": [ + 105, + 254, + 354, + 270 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 354, + 270 + ], + "score": 1.0, + "content": "2.2 Formal verification and robust training for Deep RL", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 276, + 505, + 342 + ], + "lines": [ + { + "bbox": [ + 105, + 274, + 507, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 274, + 507, + 290 + ], + "score": 1.0, + "content": "Robustness certification methods for DNN classifiers [12] have been applied in the deep RL setting:", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 288, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 106, + 288, + 505, + 299 + ], + "score": 1.0, + "content": "for example, [27] propose a policy of choosing the action with highest certified lower bound Q-value", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 298, + 506, + 311 + ], + "spans": [ + { + "bbox": [ + 106, + 298, + 506, + 311 + ], + "score": 1.0, + "content": "during execution, and [24] derived tighter robustness certificate for neural network policies under", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 308, + 506, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 506, + 321 + ], + "score": 1.0, + "content": "persistent adversarial perturbations in the system. These works study the robustness with fixed", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 320, + 506, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 506, + 332 + ], + "score": 1.0, + "content": "neural networks, while our work is focused on training neural networks that produce more robust RL", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 104, + 330, + 143, + 343 + ], + "spans": [ + { + "bbox": [ + 104, + 330, + 143, + 343 + ], + "score": 1.0, + "content": "policies.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 16.5 + }, + { + "type": "text", + "bbox": [ + 107, + 347, + 505, + 391 + ], + "lines": [ + { + "bbox": [ + 105, + 346, + 507, + 360 + ], + "spans": [ + { + "bbox": [ + 105, + 346, + 507, + 360 + ], + "score": 1.0, + "content": "The idea of adversarial training has been applied to deep RL to defend against adversarial attacks [25,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 357, + 507, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 357, + 507, + 371 + ], + "score": 1.0, + "content": "26]; however, these approaches often have much higher computational cost than standard training.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 368, + 506, + 381 + ], + "spans": [ + { + "bbox": [ + 105, + 368, + 506, + 381 + ], + "score": 1.0, + "content": "While previous work such as [21] have also trained robust agents under different threat models from", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 380, + 497, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 497, + 393 + ], + "score": 1.0, + "content": "ours, we will not be comparing against them as they have different goals and evaluation methods.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21.5 + }, + { + "type": "text", + "bbox": [ + 106, + 396, + 506, + 517 + ], + "lines": [ + { + "bbox": [ + 105, + 396, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 505, + 408 + ], + "score": 1.0, + "content": "The most relevant literature to our work are two robust training methods for deep Q-learning", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 407, + 506, + 419 + ], + "spans": [ + { + "bbox": [ + 105, + 407, + 506, + 419 + ], + "score": 1.0, + "content": "agents [18, 17]. RS-DQN [18] decouples the DQN agent into a policy and student networks, which", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 417, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 417, + 506, + 432 + ], + "score": 1.0, + "content": "enables leveraging additional constraints on the student DQN without strongly affecting learning", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 428, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 505, + 442 + ], + "score": 1.0, + "content": "of the correct Q-function, whereas SA-DQN [17] adds a hinge loss regularizer to encourage the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 439, + 506, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 506, + 453 + ], + "score": 1.0, + "content": "DQN agents to follow their original actions when there are perturbations in the observation space.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 451, + 506, + 464 + ], + "spans": [ + { + "bbox": [ + 106, + 451, + 506, + 464 + ], + "score": 1.0, + "content": "[17] also propose SA-PPO and SA-DDPG for training robust RL-agents in continuous control. In", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 461, + 506, + 475 + ], + "spans": [ + { + "bbox": [ + 104, + 461, + 506, + 475 + ], + "score": 1.0, + "content": "contrast, in RADIAL, we leverage the in-expensive robustness verification bounds to carefully design", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 473, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 505, + 486 + ], + "score": 1.0, + "content": "regularizers discouraging potentially overlapping actions of deep RL agents. As demonstrated in the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "score": 1.0, + "content": "Sec 4, our RADIAL agents outperform [18, 17] under various strength of adversarial attacks, while", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 494, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 130, + 507 + ], + "score": 1.0, + "content": "being", + "type": "text" + }, + { + "bbox": [ + 131, + 495, + 158, + 505 + ], + "score": 0.86, + "content": "2 { - } 1 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 158, + 494, + 505, + 507 + ], + "score": 1.0, + "content": "more computationally efficient to train than [17]. Moreover, we introduce a novel metric", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 505, + 499, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 499, + 518 + ], + "score": 1.0, + "content": "to evaluate agent performance against worst possible adversary that is not investigated in [18, 17].", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 29 + }, + { + "type": "title", + "bbox": [ + 107, + 529, + 299, + 541 + ], + "lines": [ + { + "bbox": [ + 105, + 527, + 301, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 301, + 545 + ], + "score": 1.0, + "content": "2.3 Basics of Deep Reinforcement Learning", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 550, + 505, + 628 + ], + "lines": [ + { + "bbox": [ + 106, + 550, + 506, + 563 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 283, + 563 + ], + "score": 1.0, + "content": "Markov Decision Process with parameters", + "type": "text" + }, + { + "bbox": [ + 283, + 550, + 360, + 562 + ], + "score": 0.93, + "content": "( S , { \\mathcal { A } } , { \\mathcal { P } } , { \\mathcal { R } } , \\gamma , s _ { 0 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 550, + 506, + 563 + ], + "score": 1.0, + "content": "is used to characterize the environ-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 561, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 210, + 573 + ], + "score": 1.0, + "content": "ments in this paper, where", + "type": "text" + }, + { + "bbox": [ + 211, + 562, + 219, + 571 + ], + "score": 0.79, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 561, + 286, + 573 + ], + "score": 1.0, + "content": "is a set of states,", + "type": "text" + }, + { + "bbox": [ + 286, + 562, + 295, + 571 + ], + "score": 0.78, + "content": "\\mathcal { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 561, + 419, + 573 + ], + "score": 1.0, + "content": "is a set of the available actions,", + "type": "text" + }, + { + "bbox": [ + 420, + 561, + 505, + 572 + ], + "score": 0.92, + "content": "\\mathcal { P } : \\mathcal { S } \\times \\mathcal { A } \\times \\mathcal { S } \\mathbb { R }", + "type": "inline_equation" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 570, + 504, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 276, + 586 + ], + "score": 1.0, + "content": "defines the transition probabilities, and", + "type": "text" + }, + { + "bbox": [ + 276, + 572, + 361, + 583 + ], + "score": 0.91, + "content": "\\mathcal { R } : \\mathcal { S } \\times \\mathcal { A } \\to \\mathbb { R }", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 570, + 493, + 586 + ], + "score": 1.0, + "content": "is the scalar reward function,", + "type": "text" + }, + { + "bbox": [ + 494, + 574, + 504, + 583 + ], + "score": 0.76, + "content": "s _ { 0 }", + "type": "inline_equation" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 581, + 507, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 254, + 596 + ], + "score": 1.0, + "content": "is the initial state distribution and", + "type": "text" + }, + { + "bbox": [ + 254, + 585, + 262, + 594 + ], + "score": 0.8, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 581, + 507, + 596 + ], + "score": 1.0, + "content": "is the discount factor. RL algorithms aim at learning a", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 593, + 504, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 218, + 606 + ], + "score": 1.0, + "content": "possibly stochastic policy", + "type": "text" + }, + { + "bbox": [ + 218, + 594, + 298, + 605 + ], + "score": 0.9, + "content": "\\pi : \\mathcal { S } \\times \\mathcal { A } \\to \\mathbb { R }", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 593, + 497, + 606 + ], + "score": 1.0, + "content": "describing the probability of taking an action", + "type": "text" + }, + { + "bbox": [ + 497, + 596, + 504, + 604 + ], + "score": 0.62, + "content": "a", + "type": "inline_equation" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 604, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 155, + 617 + ], + "score": 1.0, + "content": "given state", + "type": "text" + }, + { + "bbox": [ + 155, + 607, + 161, + 615 + ], + "score": 0.7, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 604, + 506, + 617 + ], + "score": 1.0, + "content": ". The goal of a policy is to maximize the cumulative time discounted reward of", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 615, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 149, + 629 + ], + "score": 1.0, + "content": "an episode", + "type": "text" + }, + { + "bbox": [ + 150, + 615, + 184, + 628 + ], + "score": 0.92, + "content": "\\textstyle \\sum _ { t } \\gamma ^ { t } r _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 184, + 615, + 213, + 629 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 214, + 617, + 218, + 626 + ], + "score": 0.77, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 615, + 293, + 629 + ], + "score": 1.0, + "content": "is the timestep and", + "type": "text" + }, + { + "bbox": [ + 294, + 617, + 317, + 627 + ], + "score": 0.38, + "content": "r _ { t } , a _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 615, + 333, + 629 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 334, + 617, + 343, + 627 + ], + "score": 0.85, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 615, + 496, + 629 + ], + "score": 1.0, + "content": "are reward, action and state at timestep", + "type": "text" + }, + { + "bbox": [ + 497, + 617, + 501, + 626 + ], + "score": 0.62, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 615, + 505, + 629 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 107, + 642, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 642, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 642, + 334, + 656 + ], + "score": 1.0, + "content": "Deep Q-networks (DQN) [3]. An action-value function", + "type": "text" + }, + { + "bbox": [ + 334, + 643, + 365, + 655 + ], + "score": 0.93, + "content": "Q ( s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 642, + 505, + 656 + ], + "score": 1.0, + "content": "describes the expected cumulative", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 654, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 212, + 667 + ], + "score": 1.0, + "content": "rewards given current state", + "type": "text" + }, + { + "bbox": [ + 213, + 657, + 218, + 664 + ], + "score": 0.7, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 654, + 261, + 667 + ], + "score": 1.0, + "content": "and action", + "type": "text" + }, + { + "bbox": [ + 262, + 657, + 268, + 664 + ], + "score": 0.73, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 654, + 362, + 667 + ], + "score": 1.0, + "content": ". In Q-learning, a policy", + "type": "text" + }, + { + "bbox": [ + 362, + 656, + 369, + 664 + ], + "score": 0.77, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 654, + 505, + 667 + ], + "score": 1.0, + "content": "is constructed by taking the action", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 665, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 157, + 677 + ], + "score": 1.0, + "content": "with highest", + "type": "text" + }, + { + "bbox": [ + 157, + 666, + 166, + 676 + ], + "score": 0.85, + "content": "Q", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 665, + 245, + 677 + ], + "score": 1.0, + "content": "-value. The optimal", + "type": "text" + }, + { + "bbox": [ + 245, + 666, + 254, + 676 + ], + "score": 0.84, + "content": "Q", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 665, + 337, + 677 + ], + "score": 1.0, + "content": "function, denoted as", + "type": "text" + }, + { + "bbox": [ + 337, + 665, + 372, + 677 + ], + "score": 0.92, + "content": "Q ^ { * } ( s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 373, + 665, + 505, + 677 + ], + "score": 1.0, + "content": ", satisfies the Bellman Optimality", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 104, + 674, + 507, + 691 + ], + "spans": [ + { + "bbox": [ + 104, + 674, + 150, + 691 + ], + "score": 1.0, + "content": "Equations", + "type": "text" + }, + { + "bbox": [ + 150, + 676, + 330, + 689 + ], + "score": 0.86, + "content": "\\begin{array} { r } { Q ^ { * } ( s , a ) = r + \\gamma \\mathbb { E } _ { ( s ^ { \\prime } \\mid s , a ) } \\left[ \\operatorname* { m a x } _ { a ^ { \\prime } } Q ^ { * } ( s ^ { \\prime } , a ^ { \\prime } ) \\right] } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 674, + 362, + 691 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 363, + 677, + 371, + 686 + ], + "score": 0.86, + "content": "s ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 371, + 674, + 456, + 691 + ], + "score": 1.0, + "content": "is the next state and", + "type": "text" + }, + { + "bbox": [ + 457, + 678, + 463, + 686 + ], + "score": 0.75, + "content": "r", + "type": "inline_equation" + }, + { + "bbox": [ + 463, + 674, + 507, + 691 + ], + "score": 1.0, + "content": "is reward.", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 686, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 378, + 701 + ], + "score": 1.0, + "content": "The essence of DQN is to use neural networks to approximate the", + "type": "text" + }, + { + "bbox": [ + 379, + 687, + 414, + 699 + ], + "score": 0.92, + "content": "Q ^ { * } ( s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 414, + 686, + 506, + 701 + ], + "score": 1.0, + "content": "and the networks can", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 104, + 698, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 104, + 698, + 239, + 714 + ], + "score": 1.0, + "content": "be trained by minimizing the loss", + "type": "text" + }, + { + "bbox": [ + 239, + 699, + 483, + 712 + ], + "score": 0.83, + "content": "\\begin{array} { r } { \\mathcal L ( \\theta ) = \\mathbb { E } _ { ( s , a , s ^ { \\prime } , r ) } \\left[ ( r + \\gamma \\operatorname* { m a x } _ { a ^ { \\prime } } Q ( s ^ { \\prime } , a ^ { \\prime } ; \\theta ) - Q ( s , a ; \\theta ) ) ^ { 2 } \\right] } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 698, + 506, + 714 + ], + "score": 1.0, + "content": ". The", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 710, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 506, + 724 + ], + "score": 1.0, + "content": "two baseline works on robust training for RL agents [18, 17] use more advanced versions than vanilla", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 46 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 71, + 281, + 84 + ], + "lines": [ + { + "bbox": [ + 104, + 69, + 283, + 88 + ], + "spans": [ + { + "bbox": [ + 104, + 69, + 283, + 88 + ], + "score": 1.0, + "content": "2 Related work and background", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 107, + 96, + 264, + 108 + ], + "lines": [ + { + "bbox": [ + 105, + 95, + 266, + 109 + ], + "spans": [ + { + "bbox": [ + 105, + 95, + 266, + 109 + ], + "score": 1.0, + "content": "2.1 Adversarial attacks in Deep RL", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 106, + 116, + 506, + 182 + ], + "lines": [ + { + "bbox": [ + 106, + 116, + 505, + 129 + ], + "spans": [ + { + "bbox": [ + 106, + 116, + 505, + 129 + ], + "score": 1.0, + "content": "The topic of adversarial examples in supervised learning tasks has been extensively studied, especially", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 126, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 506, + 140 + ], + "score": 1.0, + "content": "for DNN classifiers [5, 19]. More recently, [6, 7, 8] showed that deep RL agents are also vulnerable to", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 137, + 506, + 151 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 506, + 151 + ], + "score": 1.0, + "content": "adversarial perturbations, including adversarial perturbations on agents’ observations and actions [6,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 150, + 506, + 161 + ], + "spans": [ + { + "bbox": [ + 106, + 150, + 506, + 161 + ], + "score": 1.0, + "content": "7, 8], mis-specification on the environment [20], adversarial disruptions on the agents [21] and other", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 160, + 506, + 172 + ], + "spans": [ + { + "bbox": [ + 105, + 160, + 506, + 172 + ], + "score": 1.0, + "content": "adversarial agents [22]. For a review of different attack and defense settings in RL see Ilahi et al.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 168, + 130, + 184 + ], + "spans": [ + { + "bbox": [ + 105, + 168, + 130, + 184 + ], + "score": 1.0, + "content": "[23].", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 4.5, + "bbox_fs": [ + 105, + 116, + 506, + 184 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 187, + 505, + 243 + ], + "lines": [ + { + "bbox": [ + 105, + 186, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 219, + 200 + ], + "score": 1.0, + "content": "In this paper, we focus on", + "type": "text" + }, + { + "bbox": [ + 219, + 187, + 230, + 200 + ], + "score": 0.88, + "content": "\\ell _ { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 186, + 505, + 200 + ], + "score": 1.0, + "content": "-norm adversarial perturbations on agents’ observations since this", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 196, + 506, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 196, + 506, + 212 + ], + "score": 1.0, + "content": "threat model is adopted by many of the existing works investigating adversarial robustness of deep", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 208, + 506, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 208, + 417, + 222 + ], + "score": 1.0, + "content": "RL [6, 7, 8, 24, 25, 26, 27, 18, 17]. However, our framework is not limited to", + "type": "text" + }, + { + "bbox": [ + 417, + 209, + 427, + 221 + ], + "score": 0.88, + "content": "\\ell _ { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 208, + 506, + 222 + ], + "score": 1.0, + "content": "-norm perturbation", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 218, + 507, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 218, + 507, + 234 + ], + "score": 1.0, + "content": "and in fact can be easily extended to semantic perturbations (e.g. rotations, color/brightness changes,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 231, + 506, + 244 + ], + "spans": [ + { + "bbox": [ + 106, + 231, + 506, + 244 + ], + "score": 1.0, + "content": "etc) for vision-based deep RL agents (e.g. atari games) by leveraging the techniques proposed in [28].", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10, + "bbox_fs": [ + 105, + 186, + 507, + 244 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 255, + 352, + 267 + ], + "lines": [ + { + "bbox": [ + 105, + 254, + 354, + 270 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 354, + 270 + ], + "score": 1.0, + "content": "2.2 Formal verification and robust training for Deep RL", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 276, + 505, + 342 + ], + "lines": [ + { + "bbox": [ + 105, + 274, + 507, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 274, + 507, + 290 + ], + "score": 1.0, + "content": "Robustness certification methods for DNN classifiers [12] have been applied in the deep RL setting:", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 288, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 106, + 288, + 505, + 299 + ], + "score": 1.0, + "content": "for example, [27] propose a policy of choosing the action with highest certified lower bound Q-value", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 298, + 506, + 311 + ], + "spans": [ + { + "bbox": [ + 106, + 298, + 506, + 311 + ], + "score": 1.0, + "content": "during execution, and [24] derived tighter robustness certificate for neural network policies under", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 308, + 506, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 506, + 321 + ], + "score": 1.0, + "content": "persistent adversarial perturbations in the system. These works study the robustness with fixed", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 320, + 506, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 506, + 332 + ], + "score": 1.0, + "content": "neural networks, while our work is focused on training neural networks that produce more robust RL", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 104, + 330, + 143, + 343 + ], + "spans": [ + { + "bbox": [ + 104, + 330, + 143, + 343 + ], + "score": 1.0, + "content": "policies.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 16.5, + "bbox_fs": [ + 104, + 274, + 507, + 343 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 347, + 505, + 391 + ], + "lines": [ + { + "bbox": [ + 105, + 346, + 507, + 360 + ], + "spans": [ + { + "bbox": [ + 105, + 346, + 507, + 360 + ], + "score": 1.0, + "content": "The idea of adversarial training has been applied to deep RL to defend against adversarial attacks [25,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 357, + 507, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 357, + 507, + 371 + ], + "score": 1.0, + "content": "26]; however, these approaches often have much higher computational cost than standard training.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 368, + 506, + 381 + ], + "spans": [ + { + "bbox": [ + 105, + 368, + 506, + 381 + ], + "score": 1.0, + "content": "While previous work such as [21] have also trained robust agents under different threat models from", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 380, + 497, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 497, + 393 + ], + "score": 1.0, + "content": "ours, we will not be comparing against them as they have different goals and evaluation methods.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 346, + 507, + 393 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 396, + 506, + 517 + ], + "lines": [ + { + "bbox": [ + 105, + 396, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 505, + 408 + ], + "score": 1.0, + "content": "The most relevant literature to our work are two robust training methods for deep Q-learning", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 407, + 506, + 419 + ], + "spans": [ + { + "bbox": [ + 105, + 407, + 506, + 419 + ], + "score": 1.0, + "content": "agents [18, 17]. RS-DQN [18] decouples the DQN agent into a policy and student networks, which", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 417, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 417, + 506, + 432 + ], + "score": 1.0, + "content": "enables leveraging additional constraints on the student DQN without strongly affecting learning", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 428, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 505, + 442 + ], + "score": 1.0, + "content": "of the correct Q-function, whereas SA-DQN [17] adds a hinge loss regularizer to encourage the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 439, + 506, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 506, + 453 + ], + "score": 1.0, + "content": "DQN agents to follow their original actions when there are perturbations in the observation space.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 451, + 506, + 464 + ], + "spans": [ + { + "bbox": [ + 106, + 451, + 506, + 464 + ], + "score": 1.0, + "content": "[17] also propose SA-PPO and SA-DDPG for training robust RL-agents in continuous control. In", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 461, + 506, + 475 + ], + "spans": [ + { + "bbox": [ + 104, + 461, + 506, + 475 + ], + "score": 1.0, + "content": "contrast, in RADIAL, we leverage the in-expensive robustness verification bounds to carefully design", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 473, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 505, + 486 + ], + "score": 1.0, + "content": "regularizers discouraging potentially overlapping actions of deep RL agents. As demonstrated in the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "score": 1.0, + "content": "Sec 4, our RADIAL agents outperform [18, 17] under various strength of adversarial attacks, while", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 494, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 130, + 507 + ], + "score": 1.0, + "content": "being", + "type": "text" + }, + { + "bbox": [ + 131, + 495, + 158, + 505 + ], + "score": 0.86, + "content": "2 { - } 1 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 158, + 494, + 505, + 507 + ], + "score": 1.0, + "content": "more computationally efficient to train than [17]. Moreover, we introduce a novel metric", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 505, + 499, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 499, + 518 + ], + "score": 1.0, + "content": "to evaluate agent performance against worst possible adversary that is not investigated in [18, 17].", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 29, + "bbox_fs": [ + 104, + 396, + 506, + 518 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 529, + 299, + 541 + ], + "lines": [ + { + "bbox": [ + 105, + 527, + 301, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 301, + 545 + ], + "score": 1.0, + "content": "2.3 Basics of Deep Reinforcement Learning", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 550, + 505, + 628 + ], + "lines": [ + { + "bbox": [ + 106, + 550, + 506, + 563 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 283, + 563 + ], + "score": 1.0, + "content": "Markov Decision Process with parameters", + "type": "text" + }, + { + "bbox": [ + 283, + 550, + 360, + 562 + ], + "score": 0.93, + "content": "( S , { \\mathcal { A } } , { \\mathcal { P } } , { \\mathcal { R } } , \\gamma , s _ { 0 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 550, + 506, + 563 + ], + "score": 1.0, + "content": "is used to characterize the environ-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 561, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 210, + 573 + ], + "score": 1.0, + "content": "ments in this paper, where", + "type": "text" + }, + { + "bbox": [ + 211, + 562, + 219, + 571 + ], + "score": 0.79, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 561, + 286, + 573 + ], + "score": 1.0, + "content": "is a set of states,", + "type": "text" + }, + { + "bbox": [ + 286, + 562, + 295, + 571 + ], + "score": 0.78, + "content": "\\mathcal { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 561, + 419, + 573 + ], + "score": 1.0, + "content": "is a set of the available actions,", + "type": "text" + }, + { + "bbox": [ + 420, + 561, + 505, + 572 + ], + "score": 0.92, + "content": "\\mathcal { P } : \\mathcal { S } \\times \\mathcal { A } \\times \\mathcal { S } \\mathbb { R }", + "type": "inline_equation" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 570, + 504, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 276, + 586 + ], + "score": 1.0, + "content": "defines the transition probabilities, and", + "type": "text" + }, + { + "bbox": [ + 276, + 572, + 361, + 583 + ], + "score": 0.91, + "content": "\\mathcal { R } : \\mathcal { S } \\times \\mathcal { A } \\to \\mathbb { R }", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 570, + 493, + 586 + ], + "score": 1.0, + "content": "is the scalar reward function,", + "type": "text" + }, + { + "bbox": [ + 494, + 574, + 504, + 583 + ], + "score": 0.76, + "content": "s _ { 0 }", + "type": "inline_equation" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 581, + 507, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 254, + 596 + ], + "score": 1.0, + "content": "is the initial state distribution and", + "type": "text" + }, + { + "bbox": [ + 254, + 585, + 262, + 594 + ], + "score": 0.8, + "content": "\\gamma", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 581, + 507, + 596 + ], + "score": 1.0, + "content": "is the discount factor. RL algorithms aim at learning a", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 593, + 504, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 218, + 606 + ], + "score": 1.0, + "content": "possibly stochastic policy", + "type": "text" + }, + { + "bbox": [ + 218, + 594, + 298, + 605 + ], + "score": 0.9, + "content": "\\pi : \\mathcal { S } \\times \\mathcal { A } \\to \\mathbb { R }", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 593, + 497, + 606 + ], + "score": 1.0, + "content": "describing the probability of taking an action", + "type": "text" + }, + { + "bbox": [ + 497, + 596, + 504, + 604 + ], + "score": 0.62, + "content": "a", + "type": "inline_equation" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 604, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 155, + 617 + ], + "score": 1.0, + "content": "given state", + "type": "text" + }, + { + "bbox": [ + 155, + 607, + 161, + 615 + ], + "score": 0.7, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 604, + 506, + 617 + ], + "score": 1.0, + "content": ". The goal of a policy is to maximize the cumulative time discounted reward of", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 615, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 149, + 629 + ], + "score": 1.0, + "content": "an episode", + "type": "text" + }, + { + "bbox": [ + 150, + 615, + 184, + 628 + ], + "score": 0.92, + "content": "\\textstyle \\sum _ { t } \\gamma ^ { t } r _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 184, + 615, + 213, + 629 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 214, + 617, + 218, + 626 + ], + "score": 0.77, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 615, + 293, + 629 + ], + "score": 1.0, + "content": "is the timestep and", + "type": "text" + }, + { + "bbox": [ + 294, + 617, + 317, + 627 + ], + "score": 0.38, + "content": "r _ { t } , a _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 615, + 333, + 629 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 334, + 617, + 343, + 627 + ], + "score": 0.85, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 615, + 496, + 629 + ], + "score": 1.0, + "content": "are reward, action and state at timestep", + "type": "text" + }, + { + "bbox": [ + 497, + 617, + 501, + 626 + ], + "score": 0.62, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 615, + 505, + 629 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 39, + "bbox_fs": [ + 105, + 550, + 507, + 629 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 642, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 642, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 642, + 334, + 656 + ], + "score": 1.0, + "content": "Deep Q-networks (DQN) [3]. An action-value function", + "type": "text" + }, + { + "bbox": [ + 334, + 643, + 365, + 655 + ], + "score": 0.93, + "content": "Q ( s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 642, + 505, + 656 + ], + "score": 1.0, + "content": "describes the expected cumulative", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 654, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 212, + 667 + ], + "score": 1.0, + "content": "rewards given current state", + "type": "text" + }, + { + "bbox": [ + 213, + 657, + 218, + 664 + ], + "score": 0.7, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 654, + 261, + 667 + ], + "score": 1.0, + "content": "and action", + "type": "text" + }, + { + "bbox": [ + 262, + 657, + 268, + 664 + ], + "score": 0.73, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 654, + 362, + 667 + ], + "score": 1.0, + "content": ". In Q-learning, a policy", + "type": "text" + }, + { + "bbox": [ + 362, + 656, + 369, + 664 + ], + "score": 0.77, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 654, + 505, + 667 + ], + "score": 1.0, + "content": "is constructed by taking the action", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 665, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 157, + 677 + ], + "score": 1.0, + "content": "with highest", + "type": "text" + }, + { + "bbox": [ + 157, + 666, + 166, + 676 + ], + "score": 0.85, + "content": "Q", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 665, + 245, + 677 + ], + "score": 1.0, + "content": "-value. The optimal", + "type": "text" + }, + { + "bbox": [ + 245, + 666, + 254, + 676 + ], + "score": 0.84, + "content": "Q", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 665, + 337, + 677 + ], + "score": 1.0, + "content": "function, denoted as", + "type": "text" + }, + { + "bbox": [ + 337, + 665, + 372, + 677 + ], + "score": 0.92, + "content": "Q ^ { * } ( s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 373, + 665, + 505, + 677 + ], + "score": 1.0, + "content": ", satisfies the Bellman Optimality", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 104, + 674, + 507, + 691 + ], + "spans": [ + { + "bbox": [ + 104, + 674, + 150, + 691 + ], + "score": 1.0, + "content": "Equations", + "type": "text" + }, + { + "bbox": [ + 150, + 676, + 330, + 689 + ], + "score": 0.86, + "content": "\\begin{array} { r } { Q ^ { * } ( s , a ) = r + \\gamma \\mathbb { E } _ { ( s ^ { \\prime } \\mid s , a ) } \\left[ \\operatorname* { m a x } _ { a ^ { \\prime } } Q ^ { * } ( s ^ { \\prime } , a ^ { \\prime } ) \\right] } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 674, + 362, + 691 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 363, + 677, + 371, + 686 + ], + "score": 0.86, + "content": "s ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 371, + 674, + 456, + 691 + ], + "score": 1.0, + "content": "is the next state and", + "type": "text" + }, + { + "bbox": [ + 457, + 678, + 463, + 686 + ], + "score": 0.75, + "content": "r", + "type": "inline_equation" + }, + { + "bbox": [ + 463, + 674, + 507, + 691 + ], + "score": 1.0, + "content": "is reward.", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 686, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 378, + 701 + ], + "score": 1.0, + "content": "The essence of DQN is to use neural networks to approximate the", + "type": "text" + }, + { + "bbox": [ + 379, + 687, + 414, + 699 + ], + "score": 0.92, + "content": "Q ^ { * } ( s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 414, + 686, + 506, + 701 + ], + "score": 1.0, + "content": "and the networks can", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 104, + 698, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 104, + 698, + 239, + 714 + ], + "score": 1.0, + "content": "be trained by minimizing the loss", + "type": "text" + }, + { + "bbox": [ + 239, + 699, + 483, + 712 + ], + "score": 0.83, + "content": "\\begin{array} { r } { \\mathcal L ( \\theta ) = \\mathbb { E } _ { ( s , a , s ^ { \\prime } , r ) } \\left[ ( r + \\gamma \\operatorname* { m a x } _ { a ^ { \\prime } } Q ( s ^ { \\prime } , a ^ { \\prime } ; \\theta ) - Q ( s , a ; \\theta ) ) ^ { 2 } \\right] } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 698, + 506, + 714 + ], + "score": 1.0, + "content": ". The", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 710, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 506, + 724 + ], + "score": 1.0, + "content": "two baseline works on robust training for RL agents [18, 17] use more advanced versions than vanilla", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 46, + "bbox_fs": [ + 104, + 642, + 507, + 724 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 72, + 505, + 107 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 505, + 85 + ], + "score": 1.0, + "content": "DQN including Dueling-DQN [29] and Double-DQN [30]. Double-DQN uses two Q-networks to", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 82, + 505, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 187, + 97 + ], + "score": 1.0, + "content": "evaluate target value", + "type": "text" + }, + { + "bbox": [ + 188, + 84, + 213, + 95 + ], + "score": 0.9, + "content": "Q _ { \\mathrm { t a r g e t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 82, + 313, + 97 + ], + "score": 1.0, + "content": "and the one being trained", + "type": "text" + }, + { + "bbox": [ + 313, + 84, + 336, + 95 + ], + "score": 0.91, + "content": "Q \\mathrm { { a c t o r } }", + "type": "inline_equation" + }, + { + "bbox": [ + 337, + 82, + 360, + 97 + ], + "score": 1.0, + "content": ", with", + "type": "text" + }, + { + "bbox": [ + 360, + 84, + 380, + 95 + ], + "score": 0.9, + "content": "\\theta _ { \\mathrm { a c t o r } }", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 82, + 505, + 97 + ], + "score": 1.0, + "content": "being optimized by minimizing", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 92, + 179, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 92, + 139, + 108 + ], + "score": 1.0, + "content": "the loss", + "type": "text" + }, + { + "bbox": [ + 140, + 95, + 174, + 106 + ], + "score": 0.92, + "content": "{ \\mathcal { L } } ( \\theta _ { \\mathrm { a c t o r } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 92, + 179, + 108 + ], + "score": 1.0, + "content": ":", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "interline_equation", + "bbox": [ + 147, + 111, + 463, + 133 + ], + "lines": [ + { + "bbox": [ + 147, + 111, + 463, + 133 + ], + "spans": [ + { + "bbox": [ + 147, + 111, + 463, + 133 + ], + "score": 0.91, + "content": "\\mathcal { L } ( \\theta _ { \\mathrm { a c t o r } } ) = \\mathbb { E } _ { ( s , a , s ^ { \\prime } , r ) } \\Big [ ( r + \\gamma \\operatorname* { m a x } _ { a ^ { \\prime } } Q _ { \\mathrm { t a r g e t } } ( s ^ { \\prime } , a ^ { \\prime } ; \\theta _ { \\mathrm { t a r g e t } } ) - Q _ { \\mathrm { a c t o r } } ( s , a ; \\theta _ { \\mathrm { a c t o r } } ) ) ^ { 2 } \\Big ] .", + "type": "interline_equation", + "image_path": "60ad0226c345d356cd0bff991adabcb0aa0a7227d27223d42618b61a82c99386.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 147, + 111, + 463, + 133 + ], + "spans": [], + "index": 3 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 139, + 506, + 162 + ], + "lines": [ + { + "bbox": [ + 105, + 137, + 505, + 153 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 418, + 153 + ], + "score": 1.0, + "content": "Dueling-DQN improves DQN by splitting Q-values into the value of the state", + "type": "text" + }, + { + "bbox": [ + 418, + 139, + 444, + 151 + ], + "score": 0.89, + "content": "V _ { Q } ( s )", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 137, + 505, + 153 + ], + "score": 1.0, + "content": "and advantage", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 107, + 150, + 452, + 164 + ], + "spans": [ + { + "bbox": [ + 107, + 150, + 144, + 163 + ], + "score": 0.92, + "content": "A _ { Q } ( s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 150, + 330, + 164 + ], + "score": 1.0, + "content": "calculated by different output layers such that", + "type": "text" + }, + { + "bbox": [ + 330, + 150, + 448, + 163 + ], + "score": 0.92, + "content": "Q ( s , a ) = V _ { Q } ( s ) + A _ { Q } ( \\stackrel { . } { s } , \\stackrel { . } { a } )", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 150, + 452, + 164 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 106, + 166, + 505, + 235 + ], + "lines": [ + { + "bbox": [ + 105, + 166, + 505, + 180 + ], + "spans": [ + { + "bbox": [ + 105, + 166, + 505, + 180 + ], + "score": 1.0, + "content": "Asynchronous Advantage Actor Critic (A3C) [15]. A3C uses neural networks to learn a policy", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 177, + 506, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 142, + 190 + ], + "score": 1.0, + "content": "function", + "type": "text" + }, + { + "bbox": [ + 142, + 178, + 178, + 190 + ], + "score": 0.92, + "content": "\\pi ( a | s ; \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 179, + 177, + 284, + 190 + ], + "score": 1.0, + "content": "and a state-value function", + "type": "text" + }, + { + "bbox": [ + 284, + 178, + 319, + 190 + ], + "score": 0.92, + "content": "V ( s ; \\theta _ { v } )", + "type": "inline_equation" + }, + { + "bbox": [ + 319, + 177, + 421, + 190 + ], + "score": 1.0, + "content": ". Here the policy network", + "type": "text" + }, + { + "bbox": [ + 421, + 178, + 458, + 190 + ], + "score": 0.92, + "content": "\\pi ( a | s ; \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 177, + 506, + 190 + ], + "score": 1.0, + "content": "determines", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 187, + 506, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 506, + 201 + ], + "score": 1.0, + "content": "which action to take, and value function evaluates how good each state is. To update the network", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 155, + 199, + 505, + 236 + ], + "spans": [ + { + "bbox": [ + 155, + 200, + 182, + 212 + ], + "score": 0.91, + "content": "( \\theta , \\theta _ { v } )", + "type": "inline_equation" + }, + { + "bbox": [ + 282, + 199, + 352, + 236 + ], + "score": 1.0, + "content": "antage function, with hyperparam", + "type": "text" + }, + { + "bbox": [ + 352, + 200, + 364, + 210 + ], + "score": 0.88, + "content": "A _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 199, + 367, + 236 + ], + "score": 1.0, + "content": ",r", + "type": "text" + }, + { + "bbox": [ + 375, + 199, + 426, + 236 + ], + "score": 1.0, + "content": "s defined as . The networ", + "type": "text" + }, + { + "bbox": [ + 427, + 199, + 505, + 212 + ], + "score": 0.9, + "content": "A _ { t } ( s _ { t } , a _ { t } ; \\theta , \\theta _ { v } ) \\ =", + "type": "inline_equation" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 212, + 505, + 226 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 281, + 226 + ], + "score": 0.91, + "content": "\\begin{array} { r } { \\sum _ { i = 0 } ^ { k - 1 } \\gamma ^ { i } r _ { t + i } + \\gamma ^ { k } V ( s _ { t + k } ; \\theta _ { v } ) - V ( s _ { t } ; \\theta _ { v } ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 368, + 213, + 374, + 223 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 213, + 505, + 225 + ], + "score": 0.91, + "content": "( \\theta , \\theta _ { v } )", + "type": "inline_equation" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 224, + 325, + 236 + ], + "spans": [ + { + "bbox": [ + 106, + 224, + 325, + 236 + ], + "score": 1.0, + "content": "are learned by minimizing the following loss function:", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8.5 + }, + { + "type": "interline_equation", + "bbox": [ + 196, + 239, + 414, + 255 + ], + "lines": [ + { + "bbox": [ + 196, + 239, + 414, + 255 + ], + "spans": [ + { + "bbox": [ + 196, + 239, + 414, + 255 + ], + "score": 0.9, + "content": "\\begin{array} { r } { \\boldsymbol { \\mathcal { L } } ( \\boldsymbol { \\theta } , \\boldsymbol { \\theta } _ { v } ) = \\mathbb { E } _ { ( s _ { t } , a _ { t } , r _ { t } ) } \\left[ \\boldsymbol { A } _ { t } ^ { 2 } - \\boldsymbol { A } _ { t } \\log \\pi ( \\boldsymbol { a } _ { t } ) - \\boldsymbol { \\beta } \\boldsymbol { \\mathcal { H } } ( \\boldsymbol { \\pi } ) \\right] , } \\end{array}", + "type": "interline_equation", + "image_path": "f96f54cc4f586e88bf6380cd70c21aebb761f322ee9a3a3ec1937bddaeaa7e04.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 196, + 239, + 414, + 255 + ], + "spans": [], + "index": 12 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 259, + 503, + 282 + ], + "lines": [ + { + "bbox": [ + 106, + 259, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 106, + 259, + 505, + 272 + ], + "score": 1.0, + "content": "where the first term optimizes the value function, second optimizes policy function and last term", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 271, + 478, + 283 + ], + "spans": [ + { + "bbox": [ + 106, + 271, + 309, + 283 + ], + "score": 1.0, + "content": "encourages exploration by rewarding high entropy", + "type": "text" + }, + { + "bbox": [ + 310, + 271, + 319, + 280 + ], + "score": 0.82, + "content": "\\mathcal { H }", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 271, + 466, + 283 + ], + "score": 1.0, + "content": "of the policy with scaling parameter", + "type": "text" + }, + { + "bbox": [ + 466, + 271, + 474, + 282 + ], + "score": 0.84, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 474, + 271, + 478, + 283 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 106, + 293, + 503, + 316 + ], + "lines": [ + { + "bbox": [ + 105, + 292, + 505, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 292, + 505, + 307 + ], + "score": 1.0, + "content": "Proximal Policy Optimization (PPO) [16]. PPO is a critic based policy-gradient method similar", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 305, + 324, + 317 + ], + "spans": [ + { + "bbox": [ + 106, + 305, + 324, + 317 + ], + "score": 1.0, + "content": "to A3C, that works for off-policy updates unlike A3C.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 105, + 320, + 504, + 343 + ], + "lines": [ + { + "bbox": [ + 105, + 320, + 505, + 334 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 505, + 334 + ], + "score": 1.0, + "content": "PPO uses the clipping function on the ratio of action probabilities to constrain the difference between", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 332, + 326, + 344 + ], + "spans": [ + { + "bbox": [ + 106, + 332, + 326, + 344 + ], + "score": 1.0, + "content": "new and old policy. The resulting objective function is", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "interline_equation", + "bbox": [ + 137, + 348, + 473, + 376 + ], + "lines": [ + { + "bbox": [ + 137, + 348, + 473, + 376 + ], + "spans": [ + { + "bbox": [ + 137, + 348, + 473, + 376 + ], + "score": 0.92, + "content": "\\mathcal { L } ( \\theta ) = \\mathbb { E } _ { ( s _ { t } , a _ { t } , r _ { t } ) } \\left[ - \\operatorname* { m i n } ( \\frac { \\pi ( a _ { t } | s _ { t } ; \\theta ) } { \\pi ( a _ { t } | s _ { t } ; \\theta _ { \\mathrm { o l d } } ) } A _ { t } , \\mathrm { c l i p } ( \\frac { \\pi ( a _ { t } | s _ { t } ; \\theta ) } { \\pi ( a _ { t } | s _ { t } ; \\theta _ { \\mathrm { o l d } } ) } , 1 - \\eta , 1 + \\eta ) A _ { t } ) \\right] ,", + "type": "interline_equation", + "image_path": "f543c1b61e0899b8d3a54a1848051adef540eca0441210a99527da02dc8933ba.jpg" + } + ] + } + ], + "index": 20, + "virtual_lines": [ + { + "bbox": [ + 137, + 348, + 473, + 357.3333333333333 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 137, + 357.3333333333333, + 473, + 366.66666666666663 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 137, + 366.66666666666663, + 473, + 375.99999999999994 + ], + "spans": [], + "index": 21 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 380, + 505, + 414 + ], + "lines": [ + { + "bbox": [ + 105, + 380, + 506, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 132, + 393 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 132, + 383, + 139, + 392 + ], + "score": 0.82, + "content": "\\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 380, + 237, + 393 + ], + "score": 1.0, + "content": "is a hyper-parameter and", + "type": "text" + }, + { + "bbox": [ + 238, + 381, + 249, + 392 + ], + "score": 0.89, + "content": "A _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 380, + 450, + 393 + ], + "score": 1.0, + "content": "is an estimate of the advantage function at timestep", + "type": "text" + }, + { + "bbox": [ + 450, + 382, + 455, + 390 + ], + "score": 0.55, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 455, + 380, + 506, + 393 + ], + "score": 1.0, + "content": ". In addition,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 390, + 505, + 405 + ], + "spans": [ + { + "bbox": [ + 105, + 390, + 505, + 405 + ], + "score": 1.0, + "content": "PPO usually includes a term minimizes loss of the value function and rewarding entropy of the policy", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 402, + 170, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 170, + 414 + ], + "score": 1.0, + "content": "similar to A3C.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23 + }, + { + "type": "title", + "bbox": [ + 107, + 429, + 391, + 443 + ], + "lines": [ + { + "bbox": [ + 104, + 428, + 391, + 445 + ], + "spans": [ + { + "bbox": [ + 104, + 428, + 391, + 445 + ], + "score": 1.0, + "content": "3 A Robust Deep RL framework with adversarial loss", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 453, + 506, + 532 + ], + "lines": [ + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "score": 1.0, + "content": "In this section, we propose RADIAL (Robust ADversarIAl Loss)-RL, a principled framework", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 104, + 464, + 506, + 478 + ], + "spans": [ + { + "bbox": [ + 104, + 464, + 506, + 478 + ], + "score": 1.0, + "content": "for training deep RL agents robust against adversarial attacks. RADIAL designs adversarial loss", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 476, + 506, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 476, + 506, + 489 + ], + "score": 1.0, + "content": "functions by leveraging existing neural network robustness formal verification bounds. We first", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 487, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 505, + 498 + ], + "score": 1.0, + "content": "introduce the key idea of RADIAL and then elucidate a few ways to formulate adversarial loss for", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 497, + 506, + 510 + ], + "spans": [ + { + "bbox": [ + 106, + 497, + 506, + 510 + ], + "score": 1.0, + "content": "the three classical deep reinforcement learning algorithms, DQN, A3C and PPO in Sections 3.1, 3.2", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 509, + 506, + 521 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 506, + 521 + ], + "score": 1.0, + "content": "and 3.3. In Section 3.4, we propose a novel evaluation metric, Greedy Worst-Case Reward (GWC), to", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 520, + 362, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 520, + 362, + 532 + ], + "score": 1.0, + "content": "efficiently assess agent’s robustness against input perturbations.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 105, + 542, + 474, + 555 + ], + "lines": [ + { + "bbox": [ + 105, + 541, + 476, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 347, + 556 + ], + "score": 1.0, + "content": "Main idea. The training loss of the RADIAL framework,", + "type": "text" + }, + { + "bbox": [ + 347, + 543, + 381, + 554 + ], + "score": 0.84, + "content": "\\mathcal { L } _ { \\mathrm { R A D I A L } }", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 541, + 476, + 556 + ], + "score": 1.0, + "content": ", consists of two terms:", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 33 + }, + { + "type": "interline_equation", + "bbox": [ + 236, + 559, + 374, + 573 + ], + "lines": [ + { + "bbox": [ + 236, + 559, + 374, + 573 + ], + "spans": [ + { + "bbox": [ + 236, + 559, + 374, + 573 + ], + "score": 0.93, + "content": "\\mathcal { L } _ { \\mathrm { R A D I A L } } = \\kappa \\mathcal { L } _ { \\mathrm { n o m } } + ( 1 - \\kappa ) \\mathcal { L } _ { \\mathrm { a d v } } ,", + "type": "interline_equation", + "image_path": "ee80cc1c070551c37af49cd7258948e82c4a1ab254f87fbf32791fd2522fc050.jpg" + } + ] + } + ], + "index": 34, + "virtual_lines": [ + { + "bbox": [ + 236, + 559, + 374, + 573 + ], + "spans": [], + "index": 34 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 578, + 505, + 645 + ], + "lines": [ + { + "bbox": [ + 105, + 578, + 506, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 133, + 591 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 579, + 154, + 590 + ], + "score": 0.9, + "content": "{ \\mathcal { L } } _ { \\mathrm { n o m } }", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 578, + 506, + 591 + ], + "score": 1.0, + "content": "denotes the nominal loss function such as Eqs. (1)-(3) for nominal (standard) deep RL", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 589, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 153, + 601 + ], + "score": 1.0, + "content": "agents, and", + "type": "text" + }, + { + "bbox": [ + 153, + 590, + 172, + 600 + ], + "score": 0.9, + "content": "{ \\mathcal { L } } _ { \\mathrm { a d v } }", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 589, + 506, + 601 + ], + "score": 1.0, + "content": "denotes the adversarial loss which we will design carefully to account for adversarial", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 104, + 600, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 104, + 600, + 166, + 613 + ], + "score": 1.0, + "content": "perturbations.", + "type": "text" + }, + { + "bbox": [ + 167, + 603, + 174, + 610 + ], + "score": 0.72, + "content": "\\kappa", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 600, + 506, + 613 + ], + "score": 1.0, + "content": "is a hyperparameter controlling the trade-off between standard performance and", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 610, + 506, + 624 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 506, + 624 + ], + "score": 1.0, + "content": "robust performance with value between 0 and 1, and note that standard RL training algorithms have", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 107, + 622, + 506, + 635 + ], + "spans": [ + { + "bbox": [ + 107, + 623, + 132, + 632 + ], + "score": 0.89, + "content": "\\kappa = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 622, + 506, + 635 + ], + "score": 1.0, + "content": "throughout the full training process. Here we propose two principled approaches to construct", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 107, + 633, + 491, + 646 + ], + "spans": [ + { + "bbox": [ + 107, + 633, + 125, + 644 + ], + "score": 0.89, + "content": "{ \\mathcal { L } } _ { \\mathrm { a d v } }", + "type": "inline_equation" + }, + { + "bbox": [ + 126, + 633, + 491, + 646 + ], + "score": 1.0, + "content": "both via the neural network robustness certification bounds [14, 12, 13, 11, 31, 32, 33, 34]:", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 37.5 + }, + { + "type": "text", + "bbox": [ + 123, + 653, + 505, + 692 + ], + "lines": [ + { + "bbox": [ + 123, + 652, + 467, + 666 + ], + "spans": [ + { + "bbox": [ + 123, + 652, + 467, + 666 + ], + "score": 1.0, + "content": "#1. Construct an strict upper bound of the perturbed standard loss (Eq (9), (10), (7));", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 123, + 667, + 505, + 682 + ], + "spans": [ + { + "bbox": [ + 123, + 667, + 505, + 682 + ], + "score": 1.0, + "content": "#2. Design a regularizer to minimize overlap between output bounds of actions with large", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 141, + 679, + 285, + 691 + ], + "spans": [ + { + "bbox": [ + 141, + 679, + 285, + 691 + ], + "score": 1.0, + "content": "difference in outcome (Eq (5), (6)).", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 107, + 699, + 503, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 700, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 505, + 713 + ], + "score": 1.0, + "content": "The Approach #1 is well-motivated as minimizing a strict upper bound of the perturbed standard loss", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 710, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 723 + ], + "score": 1.0, + "content": "usually also decreases the true perturbed standard loss, which indicates the policy should perform", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 310, + 752 + ], + "score": 1.0, + "content": "4", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 72, + 505, + 107 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 505, + 85 + ], + "score": 1.0, + "content": "DQN including Dueling-DQN [29] and Double-DQN [30]. Double-DQN uses two Q-networks to", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 82, + 505, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 187, + 97 + ], + "score": 1.0, + "content": "evaluate target value", + "type": "text" + }, + { + "bbox": [ + 188, + 84, + 213, + 95 + ], + "score": 0.9, + "content": "Q _ { \\mathrm { t a r g e t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 82, + 313, + 97 + ], + "score": 1.0, + "content": "and the one being trained", + "type": "text" + }, + { + "bbox": [ + 313, + 84, + 336, + 95 + ], + "score": 0.91, + "content": "Q \\mathrm { { a c t o r } }", + "type": "inline_equation" + }, + { + "bbox": [ + 337, + 82, + 360, + 97 + ], + "score": 1.0, + "content": ", with", + "type": "text" + }, + { + "bbox": [ + 360, + 84, + 380, + 95 + ], + "score": 0.9, + "content": "\\theta _ { \\mathrm { a c t o r } }", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 82, + 505, + 97 + ], + "score": 1.0, + "content": "being optimized by minimizing", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 92, + 179, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 92, + 139, + 108 + ], + "score": 1.0, + "content": "the loss", + "type": "text" + }, + { + "bbox": [ + 140, + 95, + 174, + 106 + ], + "score": 0.92, + "content": "{ \\mathcal { L } } ( \\theta _ { \\mathrm { a c t o r } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 92, + 179, + 108 + ], + "score": 1.0, + "content": ":", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 105, + 72, + 505, + 108 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 147, + 111, + 463, + 133 + ], + "lines": [ + { + "bbox": [ + 147, + 111, + 463, + 133 + ], + "spans": [ + { + "bbox": [ + 147, + 111, + 463, + 133 + ], + "score": 0.91, + "content": "\\mathcal { L } ( \\theta _ { \\mathrm { a c t o r } } ) = \\mathbb { E } _ { ( s , a , s ^ { \\prime } , r ) } \\Big [ ( r + \\gamma \\operatorname* { m a x } _ { a ^ { \\prime } } Q _ { \\mathrm { t a r g e t } } ( s ^ { \\prime } , a ^ { \\prime } ; \\theta _ { \\mathrm { t a r g e t } } ) - Q _ { \\mathrm { a c t o r } } ( s , a ; \\theta _ { \\mathrm { a c t o r } } ) ) ^ { 2 } \\Big ] .", + "type": "interline_equation", + "image_path": "60ad0226c345d356cd0bff991adabcb0aa0a7227d27223d42618b61a82c99386.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 147, + 111, + 463, + 133 + ], + "spans": [], + "index": 3 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 139, + 506, + 162 + ], + "lines": [ + { + "bbox": [ + 105, + 137, + 505, + 153 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 418, + 153 + ], + "score": 1.0, + "content": "Dueling-DQN improves DQN by splitting Q-values into the value of the state", + "type": "text" + }, + { + "bbox": [ + 418, + 139, + 444, + 151 + ], + "score": 0.89, + "content": "V _ { Q } ( s )", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 137, + 505, + 153 + ], + "score": 1.0, + "content": "and advantage", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 107, + 150, + 452, + 164 + ], + "spans": [ + { + "bbox": [ + 107, + 150, + 144, + 163 + ], + "score": 0.92, + "content": "A _ { Q } ( s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 150, + 330, + 164 + ], + "score": 1.0, + "content": "calculated by different output layers such that", + "type": "text" + }, + { + "bbox": [ + 330, + 150, + 448, + 163 + ], + "score": 0.92, + "content": "Q ( s , a ) = V _ { Q } ( s ) + A _ { Q } ( \\stackrel { . } { s } , \\stackrel { . } { a } )", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 150, + 452, + 164 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5, + "bbox_fs": [ + 105, + 137, + 505, + 164 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 166, + 505, + 235 + ], + "lines": [ + { + "bbox": [ + 105, + 166, + 505, + 180 + ], + "spans": [ + { + "bbox": [ + 105, + 166, + 505, + 180 + ], + "score": 1.0, + "content": "Asynchronous Advantage Actor Critic (A3C) [15]. A3C uses neural networks to learn a policy", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 177, + 506, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 142, + 190 + ], + "score": 1.0, + "content": "function", + "type": "text" + }, + { + "bbox": [ + 142, + 178, + 178, + 190 + ], + "score": 0.92, + "content": "\\pi ( a | s ; \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 179, + 177, + 284, + 190 + ], + "score": 1.0, + "content": "and a state-value function", + "type": "text" + }, + { + "bbox": [ + 284, + 178, + 319, + 190 + ], + "score": 0.92, + "content": "V ( s ; \\theta _ { v } )", + "type": "inline_equation" + }, + { + "bbox": [ + 319, + 177, + 421, + 190 + ], + "score": 1.0, + "content": ". Here the policy network", + "type": "text" + }, + { + "bbox": [ + 421, + 178, + 458, + 190 + ], + "score": 0.92, + "content": "\\pi ( a | s ; \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 177, + 506, + 190 + ], + "score": 1.0, + "content": "determines", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 187, + 506, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 506, + 201 + ], + "score": 1.0, + "content": "which action to take, and value function evaluates how good each state is. To update the network", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 155, + 199, + 505, + 236 + ], + "spans": [ + { + "bbox": [ + 155, + 200, + 182, + 212 + ], + "score": 0.91, + "content": "( \\theta , \\theta _ { v } )", + "type": "inline_equation" + }, + { + "bbox": [ + 282, + 199, + 352, + 236 + ], + "score": 1.0, + "content": "antage function, with hyperparam", + "type": "text" + }, + { + "bbox": [ + 352, + 200, + 364, + 210 + ], + "score": 0.88, + "content": "A _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 199, + 367, + 236 + ], + "score": 1.0, + "content": ",r", + "type": "text" + }, + { + "bbox": [ + 375, + 199, + 426, + 236 + ], + "score": 1.0, + "content": "s defined as . The networ", + "type": "text" + }, + { + "bbox": [ + 427, + 199, + 505, + 212 + ], + "score": 0.9, + "content": "A _ { t } ( s _ { t } , a _ { t } ; \\theta , \\theta _ { v } ) \\ =", + "type": "inline_equation" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 212, + 505, + 226 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 281, + 226 + ], + "score": 0.91, + "content": "\\begin{array} { r } { \\sum _ { i = 0 } ^ { k - 1 } \\gamma ^ { i } r _ { t + i } + \\gamma ^ { k } V ( s _ { t + k } ; \\theta _ { v } ) - V ( s _ { t } ; \\theta _ { v } ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 368, + 213, + 374, + 223 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 213, + 505, + 225 + ], + "score": 0.91, + "content": "( \\theta , \\theta _ { v } )", + "type": "inline_equation" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 224, + 325, + 236 + ], + "spans": [ + { + "bbox": [ + 106, + 224, + 325, + 236 + ], + "score": 1.0, + "content": "are learned by minimizing the following loss function:", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 166, + 506, + 236 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 196, + 239, + 414, + 255 + ], + "lines": [ + { + "bbox": [ + 196, + 239, + 414, + 255 + ], + "spans": [ + { + "bbox": [ + 196, + 239, + 414, + 255 + ], + "score": 0.9, + "content": "\\begin{array} { r } { \\boldsymbol { \\mathcal { L } } ( \\boldsymbol { \\theta } , \\boldsymbol { \\theta } _ { v } ) = \\mathbb { E } _ { ( s _ { t } , a _ { t } , r _ { t } ) } \\left[ \\boldsymbol { A } _ { t } ^ { 2 } - \\boldsymbol { A } _ { t } \\log \\pi ( \\boldsymbol { a } _ { t } ) - \\boldsymbol { \\beta } \\boldsymbol { \\mathcal { H } } ( \\boldsymbol { \\pi } ) \\right] , } \\end{array}", + "type": "interline_equation", + "image_path": "f96f54cc4f586e88bf6380cd70c21aebb761f322ee9a3a3ec1937bddaeaa7e04.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 196, + 239, + 414, + 255 + ], + "spans": [], + "index": 12 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 259, + 503, + 282 + ], + "lines": [ + { + "bbox": [ + 106, + 259, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 106, + 259, + 505, + 272 + ], + "score": 1.0, + "content": "where the first term optimizes the value function, second optimizes policy function and last term", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 271, + 478, + 283 + ], + "spans": [ + { + "bbox": [ + 106, + 271, + 309, + 283 + ], + "score": 1.0, + "content": "encourages exploration by rewarding high entropy", + "type": "text" + }, + { + "bbox": [ + 310, + 271, + 319, + 280 + ], + "score": 0.82, + "content": "\\mathcal { H }", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 271, + 466, + 283 + ], + "score": 1.0, + "content": "of the policy with scaling parameter", + "type": "text" + }, + { + "bbox": [ + 466, + 271, + 474, + 282 + ], + "score": 0.84, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 474, + 271, + 478, + 283 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5, + "bbox_fs": [ + 106, + 259, + 505, + 283 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 293, + 503, + 316 + ], + "lines": [ + { + "bbox": [ + 105, + 292, + 505, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 292, + 505, + 307 + ], + "score": 1.0, + "content": "Proximal Policy Optimization (PPO) [16]. PPO is a critic based policy-gradient method similar", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 305, + 324, + 317 + ], + "spans": [ + { + "bbox": [ + 106, + 305, + 324, + 317 + ], + "score": 1.0, + "content": "to A3C, that works for off-policy updates unlike A3C.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 292, + 505, + 317 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 320, + 504, + 343 + ], + "lines": [ + { + "bbox": [ + 105, + 320, + 505, + 334 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 505, + 334 + ], + "score": 1.0, + "content": "PPO uses the clipping function on the ratio of action probabilities to constrain the difference between", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 332, + 326, + 344 + ], + "spans": [ + { + "bbox": [ + 106, + 332, + 326, + 344 + ], + "score": 1.0, + "content": "new and old policy. The resulting objective function is", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5, + "bbox_fs": [ + 105, + 320, + 505, + 344 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 137, + 348, + 473, + 376 + ], + "lines": [ + { + "bbox": [ + 137, + 348, + 473, + 376 + ], + "spans": [ + { + "bbox": [ + 137, + 348, + 473, + 376 + ], + "score": 0.92, + "content": "\\mathcal { L } ( \\theta ) = \\mathbb { E } _ { ( s _ { t } , a _ { t } , r _ { t } ) } \\left[ - \\operatorname* { m i n } ( \\frac { \\pi ( a _ { t } | s _ { t } ; \\theta ) } { \\pi ( a _ { t } | s _ { t } ; \\theta _ { \\mathrm { o l d } } ) } A _ { t } , \\mathrm { c l i p } ( \\frac { \\pi ( a _ { t } | s _ { t } ; \\theta ) } { \\pi ( a _ { t } | s _ { t } ; \\theta _ { \\mathrm { o l d } } ) } , 1 - \\eta , 1 + \\eta ) A _ { t } ) \\right] ,", + "type": "interline_equation", + "image_path": "f543c1b61e0899b8d3a54a1848051adef540eca0441210a99527da02dc8933ba.jpg" + } + ] + } + ], + "index": 20, + "virtual_lines": [ + { + "bbox": [ + 137, + 348, + 473, + 357.3333333333333 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 137, + 357.3333333333333, + 473, + 366.66666666666663 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 137, + 366.66666666666663, + 473, + 375.99999999999994 + ], + "spans": [], + "index": 21 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 380, + 505, + 414 + ], + "lines": [ + { + "bbox": [ + 105, + 380, + 506, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 132, + 393 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 132, + 383, + 139, + 392 + ], + "score": 0.82, + "content": "\\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 380, + 237, + 393 + ], + "score": 1.0, + "content": "is a hyper-parameter and", + "type": "text" + }, + { + "bbox": [ + 238, + 381, + 249, + 392 + ], + "score": 0.89, + "content": "A _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 380, + 450, + 393 + ], + "score": 1.0, + "content": "is an estimate of the advantage function at timestep", + "type": "text" + }, + { + "bbox": [ + 450, + 382, + 455, + 390 + ], + "score": 0.55, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 455, + 380, + 506, + 393 + ], + "score": 1.0, + "content": ". In addition,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 390, + 505, + 405 + ], + "spans": [ + { + "bbox": [ + 105, + 390, + 505, + 405 + ], + "score": 1.0, + "content": "PPO usually includes a term minimizes loss of the value function and rewarding entropy of the policy", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 402, + 170, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 170, + 414 + ], + "score": 1.0, + "content": "similar to A3C.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 380, + 506, + 414 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 429, + 391, + 443 + ], + "lines": [ + { + "bbox": [ + 104, + 428, + 391, + 445 + ], + "spans": [ + { + "bbox": [ + 104, + 428, + 391, + 445 + ], + "score": 1.0, + "content": "3 A Robust Deep RL framework with adversarial loss", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 453, + 506, + 532 + ], + "lines": [ + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "score": 1.0, + "content": "In this section, we propose RADIAL (Robust ADversarIAl Loss)-RL, a principled framework", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 104, + 464, + 506, + 478 + ], + "spans": [ + { + "bbox": [ + 104, + 464, + 506, + 478 + ], + "score": 1.0, + "content": "for training deep RL agents robust against adversarial attacks. RADIAL designs adversarial loss", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 476, + 506, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 476, + 506, + 489 + ], + "score": 1.0, + "content": "functions by leveraging existing neural network robustness formal verification bounds. We first", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 487, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 505, + 498 + ], + "score": 1.0, + "content": "introduce the key idea of RADIAL and then elucidate a few ways to formulate adversarial loss for", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 497, + 506, + 510 + ], + "spans": [ + { + "bbox": [ + 106, + 497, + 506, + 510 + ], + "score": 1.0, + "content": "the three classical deep reinforcement learning algorithms, DQN, A3C and PPO in Sections 3.1, 3.2", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 509, + 506, + 521 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 506, + 521 + ], + "score": 1.0, + "content": "and 3.3. In Section 3.4, we propose a novel evaluation metric, Greedy Worst-Case Reward (GWC), to", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 520, + 362, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 520, + 362, + 532 + ], + "score": 1.0, + "content": "efficiently assess agent’s robustness against input perturbations.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 29, + "bbox_fs": [ + 104, + 453, + 506, + 532 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 542, + 474, + 555 + ], + "lines": [ + { + "bbox": [ + 105, + 541, + 476, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 347, + 556 + ], + "score": 1.0, + "content": "Main idea. The training loss of the RADIAL framework,", + "type": "text" + }, + { + "bbox": [ + 347, + 543, + 381, + 554 + ], + "score": 0.84, + "content": "\\mathcal { L } _ { \\mathrm { R A D I A L } }", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 541, + 476, + 556 + ], + "score": 1.0, + "content": ", consists of two terms:", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 33, + "bbox_fs": [ + 105, + 541, + 476, + 556 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 236, + 559, + 374, + 573 + ], + "lines": [ + { + "bbox": [ + 236, + 559, + 374, + 573 + ], + "spans": [ + { + "bbox": [ + 236, + 559, + 374, + 573 + ], + "score": 0.93, + "content": "\\mathcal { L } _ { \\mathrm { R A D I A L } } = \\kappa \\mathcal { L } _ { \\mathrm { n o m } } + ( 1 - \\kappa ) \\mathcal { L } _ { \\mathrm { a d v } } ,", + "type": "interline_equation", + "image_path": "ee80cc1c070551c37af49cd7258948e82c4a1ab254f87fbf32791fd2522fc050.jpg" + } + ] + } + ], + "index": 34, + "virtual_lines": [ + { + "bbox": [ + 236, + 559, + 374, + 573 + ], + "spans": [], + "index": 34 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 578, + 505, + 645 + ], + "lines": [ + { + "bbox": [ + 105, + 578, + 506, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 133, + 591 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 579, + 154, + 590 + ], + "score": 0.9, + "content": "{ \\mathcal { L } } _ { \\mathrm { n o m } }", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 578, + 506, + 591 + ], + "score": 1.0, + "content": "denotes the nominal loss function such as Eqs. (1)-(3) for nominal (standard) deep RL", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 589, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 153, + 601 + ], + "score": 1.0, + "content": "agents, and", + "type": "text" + }, + { + "bbox": [ + 153, + 590, + 172, + 600 + ], + "score": 0.9, + "content": "{ \\mathcal { L } } _ { \\mathrm { a d v } }", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 589, + 506, + 601 + ], + "score": 1.0, + "content": "denotes the adversarial loss which we will design carefully to account for adversarial", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 104, + 600, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 104, + 600, + 166, + 613 + ], + "score": 1.0, + "content": "perturbations.", + "type": "text" + }, + { + "bbox": [ + 167, + 603, + 174, + 610 + ], + "score": 0.72, + "content": "\\kappa", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 600, + 506, + 613 + ], + "score": 1.0, + "content": "is a hyperparameter controlling the trade-off between standard performance and", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 610, + 506, + 624 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 506, + 624 + ], + "score": 1.0, + "content": "robust performance with value between 0 and 1, and note that standard RL training algorithms have", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 107, + 622, + 506, + 635 + ], + "spans": [ + { + "bbox": [ + 107, + 623, + 132, + 632 + ], + "score": 0.89, + "content": "\\kappa = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 622, + 506, + 635 + ], + "score": 1.0, + "content": "throughout the full training process. Here we propose two principled approaches to construct", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 107, + 633, + 491, + 646 + ], + "spans": [ + { + "bbox": [ + 107, + 633, + 125, + 644 + ], + "score": 0.89, + "content": "{ \\mathcal { L } } _ { \\mathrm { a d v } }", + "type": "inline_equation" + }, + { + "bbox": [ + 126, + 633, + 491, + 646 + ], + "score": 1.0, + "content": "both via the neural network robustness certification bounds [14, 12, 13, 11, 31, 32, 33, 34]:", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 37.5, + "bbox_fs": [ + 104, + 578, + 506, + 646 + ] + }, + { + "type": "text", + "bbox": [ + 123, + 653, + 505, + 692 + ], + "lines": [ + { + "bbox": [ + 123, + 652, + 467, + 666 + ], + "spans": [ + { + "bbox": [ + 123, + 652, + 467, + 666 + ], + "score": 1.0, + "content": "#1. Construct an strict upper bound of the perturbed standard loss (Eq (9), (10), (7));", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 123, + 667, + 505, + 682 + ], + "spans": [ + { + "bbox": [ + 123, + 667, + 505, + 682 + ], + "score": 1.0, + "content": "#2. Design a regularizer to minimize overlap between output bounds of actions with large", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 141, + 679, + 285, + 691 + ], + "spans": [ + { + "bbox": [ + 141, + 679, + 285, + 691 + ], + "score": 1.0, + "content": "difference in outcome (Eq (5), (6)).", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42, + "bbox_fs": [ + 123, + 652, + 505, + 691 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 699, + 503, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 700, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 505, + 713 + ], + "score": 1.0, + "content": "The Approach #1 is well-motivated as minimizing a strict upper bound of the perturbed standard loss", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 710, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 723 + ], + "score": 1.0, + "content": "usually also decreases the true perturbed standard loss, which indicates the policy should perform", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 73, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 106, + 73, + 360, + 86 + ], + "score": 1.0, + "content": "well under adversarial perturbations. Alternatively, Approach", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 360, + 73, + 371, + 83 + ], + "score": 0.42, + "content": "\\# 2", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 372, + 73, + 505, + 86 + ], + "score": 1.0, + "content": "is motivated by the idea that we", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 84, + 465, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 84, + 465, + 96 + ], + "score": 1.0, + "content": "want to avoid choosing a significantly worse action because of a small input perturbation.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + } + ], + "index": 44.5, + "bbox_fs": [ + 105, + 700, + 505, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 72, + 504, + 95 + ], + "lines": [ + { + "bbox": [ + 106, + 73, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 106, + 73, + 360, + 86 + ], + "score": 1.0, + "content": "well under adversarial perturbations. Alternatively, Approach", + "type": "text" + }, + { + "bbox": [ + 360, + 73, + 371, + 83 + ], + "score": 0.42, + "content": "\\# 2", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 73, + 505, + 86 + ], + "score": 1.0, + "content": "is motivated by the idea that we", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 84, + 465, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 84, + 465, + 96 + ], + "score": 1.0, + "content": "want to avoid choosing a significantly worse action because of a small input perturbation.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 106, + 99, + 505, + 253 + ], + "lines": [ + { + "bbox": [ + 105, + 100, + 505, + 112 + ], + "spans": [ + { + "bbox": [ + 105, + 100, + 271, + 112 + ], + "score": 1.0, + "content": "The foundation of both Approach #1 and", + "type": "text" + }, + { + "bbox": [ + 271, + 100, + 283, + 110 + ], + "score": 0.31, + "content": "\\# 2", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 100, + 505, + 112 + ], + "score": 1.0, + "content": "lies in the robustness formal verification tools to derive", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 111, + 506, + 123 + ], + "spans": [ + { + "bbox": [ + 105, + 111, + 506, + 123 + ], + "score": 1.0, + "content": "output bounds of neural networks under input perturbations. Specifically, for a given neural network,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 122, + 506, + 134 + ], + "spans": [ + { + "bbox": [ + 105, + 122, + 142, + 134 + ], + "score": 1.0, + "content": "suppose", + "type": "text" + }, + { + "bbox": [ + 142, + 122, + 165, + 134 + ], + "score": 0.92, + "content": "z _ { i } ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 122, + 263, + 134 + ], + "score": 1.0, + "content": "is the activation of the", + "type": "text" + }, + { + "bbox": [ + 264, + 123, + 268, + 132 + ], + "score": 0.27, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 122, + 432, + 134 + ], + "score": 1.0, + "content": "th layer of a neural network with input", + "type": "text" + }, + { + "bbox": [ + 433, + 124, + 439, + 132 + ], + "score": 0.76, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 439, + 122, + 506, + 134 + ], + "score": 1.0, + "content": ". The goal of a", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 132, + 505, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 505, + 145 + ], + "score": 1.0, + "content": "robustness verification algorithm is to compute layer-wise lower and upper bounds of the neural", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 143, + 506, + 156 + ], + "spans": [ + { + "bbox": [ + 104, + 143, + 187, + 156 + ], + "score": 1.0, + "content": "network, denoted as", + "type": "text" + }, + { + "bbox": [ + 188, + 144, + 219, + 156 + ], + "score": 0.92, + "content": "\\underline { { z } } _ { i } ( x , \\epsilon )", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 143, + 237, + 156 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 238, + 144, + 269, + 155 + ], + "score": 0.91, + "content": "\\overline { { z } } _ { i } ( x , \\epsilon )", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 143, + 311, + 156 + ], + "score": 1.0, + "content": ", such that", + "type": "text" + }, + { + "bbox": [ + 311, + 144, + 437, + 156 + ], + "score": 0.93, + "content": "\\underline { { z } } _ { i } ( x , \\epsilon ) \\leq z _ { i } ( x + \\delta ) \\leq \\overline { { z _ { i } } } ( x , \\epsilon )", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 143, + 506, + 156 + ], + "score": 1.0, + "content": ", for any additive", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 154, + 506, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 182, + 167 + ], + "score": 1.0, + "content": "input perturbation", + "type": "text" + }, + { + "bbox": [ + 183, + 155, + 189, + 164 + ], + "score": 0.79, + "content": "\\delta", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 154, + 203, + 167 + ], + "score": 1.0, + "content": "on", + "type": "text" + }, + { + "bbox": [ + 203, + 157, + 210, + 164 + ], + "score": 0.8, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 154, + 232, + 167 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 232, + 155, + 272, + 167 + ], + "score": 0.91, + "content": "| | \\delta | | _ { p } \\leq \\epsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 272, + 154, + 506, + 167 + ], + "score": 1.0, + "content": ". We will apply robustness verification algorithms on the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 165, + 504, + 178 + ], + "spans": [ + { + "bbox": [ + 106, + 165, + 495, + 178 + ], + "score": 1.0, + "content": "Q-networks (for DQN) or policy networks (for A3C and PPO) to get layer-wise output bounds of", + "type": "text" + }, + { + "bbox": [ + 495, + 166, + 504, + 177 + ], + "score": 0.84, + "content": "Q", + "type": "inline_equation" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 176, + 506, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 123, + 190 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 124, + 178, + 131, + 186 + ], + "score": 0.75, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 131, + 176, + 506, + 190 + ], + "score": 1.0, + "content": ". These output bounds can be used to calculate an upper bound of the original loss function", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 187, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 106, + 187, + 275, + 200 + ], + "score": 1.0, + "content": "under worst-case adversarial perturbation", + "type": "text" + }, + { + "bbox": [ + 276, + 187, + 294, + 198 + ], + "score": 0.9, + "content": "{ \\mathcal { L } } _ { \\mathrm { a d v } }", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 187, + 505, + 200 + ], + "score": 1.0, + "content": "for Approach #1. Similarly, the layer-wise bound is", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 198, + 506, + 211 + ], + "spans": [ + { + "bbox": [ + 106, + 198, + 410, + 211 + ], + "score": 1.0, + "content": "used to minimize the overlap of output intervals as proposed in Approach", + "type": "text" + }, + { + "bbox": [ + 410, + 198, + 422, + 208 + ], + "score": 0.32, + "content": "\\# 2", + "type": "inline_equation" + }, + { + "bbox": [ + 422, + 198, + 506, + 211 + ], + "score": 1.0, + "content": ". For the purpose of", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 209, + 506, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 209, + 506, + 222 + ], + "score": 1.0, + "content": "training efficiency, IBP [14] is used to compute the layer-wise bounds for the neural networks, but", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 219, + 505, + 232 + ], + "spans": [ + { + "bbox": [ + 105, + 219, + 505, + 232 + ], + "score": 1.0, + "content": "other differentiable certification methods [12, 13, 11, 31, 32, 33] could be applied directly (albeit", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 231, + 505, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 369, + 244 + ], + "score": 1.0, + "content": "may incur additional computation cost). Our experiments focus on", + "type": "text" + }, + { + "bbox": [ + 370, + 232, + 399, + 243 + ], + "score": 0.9, + "content": "p = \\infty", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 231, + 505, + 244 + ], + "score": 1.0, + "content": "to compare with baselines", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 241, + 274, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 264, + 255 + ], + "score": 1.0, + "content": "but the methodology works for general", + "type": "text" + }, + { + "bbox": [ + 264, + 244, + 270, + 253 + ], + "score": 0.79, + "content": "p", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 241, + 274, + 255 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 8.5 + }, + { + "type": "title", + "bbox": [ + 107, + 264, + 195, + 277 + ], + "lines": [ + { + "bbox": [ + 104, + 263, + 197, + 281 + ], + "spans": [ + { + "bbox": [ + 104, + 263, + 197, + 281 + ], + "score": 1.0, + "content": "3.1 RADIAL-DQN", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 285, + 505, + 355 + ], + "lines": [ + { + "bbox": [ + 105, + 285, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 279, + 298 + ], + "score": 1.0, + "content": "For Dueling-DQN, the advantage function", + "type": "text" + }, + { + "bbox": [ + 280, + 286, + 295, + 298 + ], + "score": 0.9, + "content": "A _ { Q }", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 285, + 505, + 298 + ], + "score": 1.0, + "content": "is used to decide which action to take and the value", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 296, + 505, + 309 + ], + "spans": [ + { + "bbox": [ + 106, + 296, + 141, + 309 + ], + "score": 1.0, + "content": "function", + "type": "text" + }, + { + "bbox": [ + 141, + 297, + 155, + 309 + ], + "score": 0.89, + "content": "V _ { Q }", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 296, + 388, + 309 + ], + "score": 1.0, + "content": "is only important for training. Hence, we only need to make", + "type": "text" + }, + { + "bbox": [ + 389, + 297, + 403, + 308 + ], + "score": 0.89, + "content": "A _ { Q }", + "type": "inline_equation" + }, + { + "bbox": [ + 404, + 296, + 505, + 309 + ], + "score": 1.0, + "content": "robust and the Q function", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 104, + 307, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 104, + 307, + 226, + 323 + ], + "score": 1.0, + "content": "is lower and upper bounded by", + "type": "text" + }, + { + "bbox": [ + 226, + 308, + 357, + 322 + ], + "score": 0.91, + "content": "\\underline { { Q } } ( s , a , \\epsilon ) = V _ { Q } ( s ) + \\underline { { A _ { Q } } } ( s , a , \\epsilon )", + "type": "inline_equation" + }, + { + "bbox": [ + 358, + 307, + 374, + 323 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 374, + 308, + 505, + 321 + ], + "score": 0.92, + "content": "\\overline { { { Q } } } ( s , a , \\epsilon ) = V _ { Q } ( s ) + \\overline { { { A _ { Q } } } } ( s , a , \\epsilon )", + "type": "inline_equation" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 321, + 505, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 321, + 127, + 335 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 127, + 324, + 132, + 331 + ], + "score": 0.74, + "content": "\\epsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 321, + 264, + 335 + ], + "score": 1.0, + "content": "-bounded perturbations to input", + "type": "text" + }, + { + "bbox": [ + 264, + 324, + 270, + 331 + ], + "score": 0.68, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 321, + 505, + 335 + ], + "score": 1.0, + "content": ". In RADIAL we proposde two approaches to derive the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 332, + 506, + 346 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 170, + 346 + ], + "score": 1.0, + "content": "adversarial loss", + "type": "text" + }, + { + "bbox": [ + 170, + 333, + 189, + 344 + ], + "score": 0.89, + "content": "{ \\mathcal { L } } _ { \\mathrm { a d v } }", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 332, + 506, + 346 + ], + "score": 1.0, + "content": "; however, due to the space constraints, we describe the approach that has better", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 344, + 413, + 356 + ], + "spans": [ + { + "bbox": [ + 106, + 344, + 413, + 356 + ], + "score": 1.0, + "content": "empirical performance in the main text, and leave the other in the Appendix.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 106, + 359, + 505, + 448 + ], + "lines": [ + { + "bbox": [ + 106, + 360, + 505, + 372 + ], + "spans": [ + { + "bbox": [ + 106, + 360, + 243, + 372 + ], + "score": 1.0, + "content": "For DQN, we find that Approach", + "type": "text" + }, + { + "bbox": [ + 244, + 360, + 255, + 370 + ], + "score": 0.26, + "content": "\\# 2", + "type": "inline_equation" + }, + { + "bbox": [ + 256, + 360, + 505, + 372 + ], + "score": 1.0, + "content": "performs better. The goal of Approach #2 is to minimize the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 371, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 106, + 371, + 505, + 383 + ], + "score": 1.0, + "content": "weighted overlap of activation bounds for different actions (Fig. 2). The idea is to minimize only", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 382, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 382, + 505, + 394 + ], + "score": 1.0, + "content": "what is necessary for robust performance, overlap. If there is no overlap, the original action’s Q-value", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 393, + 505, + 405 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 505, + 405 + ], + "score": 1.0, + "content": "is guaranteed to be higher than others even under perturbation, so the agent won’t change it’s behavior", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 404, + 506, + 416 + ], + "spans": [ + { + "bbox": [ + 106, + 404, + 506, + 416 + ], + "score": 1.0, + "content": "under perturbation. However not all overlap is equally important. If two actions have a very similar", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 415, + 506, + 427 + ], + "spans": [ + { + "bbox": [ + 106, + 415, + 115, + 426 + ], + "score": 0.25, + "content": "\\mathrm { Q }", + "type": "inline_equation" + }, + { + "bbox": [ + 115, + 415, + 506, + 427 + ], + "score": 1.0, + "content": "-value, overlap is acceptable, as taking a different but equally good action under perturbation is not", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 104, + 425, + 506, + 438 + ], + "spans": [ + { + "bbox": [ + 104, + 425, + 311, + 438 + ], + "score": 1.0, + "content": "a problem. To address this we added weighting by", + "type": "text" + }, + { + "bbox": [ + 312, + 425, + 331, + 437 + ], + "score": 0.91, + "content": "Q _ { \\mathrm { d i f f } }", + "type": "inline_equation" + }, + { + "bbox": [ + 332, + 425, + 506, + 438 + ], + "score": 1.0, + "content": ", which helps by multiplying overlaps with", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 435, + 475, + 450 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 475, + 450 + ], + "score": 1.0, + "content": "similar Q-values by a small number and overlaps with different Q-values by a large number.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 108, + 452, + 270, + 464 + ], + "lines": [ + { + "bbox": [ + 106, + 451, + 271, + 465 + ], + "spans": [ + { + "bbox": [ + 106, + 451, + 271, + 465 + ], + "score": 1.0, + "content": "The final loss loss function is as follows:", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "interline_equation", + "bbox": [ + 194, + 462, + 417, + 489 + ], + "lines": [ + { + "bbox": [ + 194, + 462, + 417, + 489 + ], + "spans": [ + { + "bbox": [ + 194, + 462, + 417, + 489 + ], + "score": 0.93, + "content": "\\mathcal { L } _ { \\mathrm { a d v } } ( \\theta _ { \\mathrm { a c t o r } } , \\epsilon ) = \\mathbb { E } _ { ( s , a , s ^ { \\prime } , r ) } [ \\sum _ { y } Q _ { \\mathrm { d i f f } } ( s , y ) \\cdot O v l ( s , y , \\epsilon ) ]", + "type": "interline_equation", + "image_path": "33c317fca69d8030101ff07179f67cd136e0e6baf7037510f03ea4b73724c03d.jpg" + } + ] + } + ], + "index": 32.5, + "virtual_lines": [ + { + "bbox": [ + 194, + 462, + 417, + 475.5 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 194, + 475.5, + 417, + 489.0 + ], + "spans": [], + "index": 33 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 491, + 132, + 501 + ], + "lines": [ + { + "bbox": [ + 105, + 489, + 135, + 503 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 135, + 503 + ], + "score": 1.0, + "content": "where", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "interline_equation", + "bbox": [ + 115, + 502, + 495, + 518 + ], + "lines": [ + { + "bbox": [ + 115, + 502, + 495, + 518 + ], + "spans": [ + { + "bbox": [ + 115, + 502, + 495, + 518 + ], + "score": 0.9, + "content": "Q _ { \\mathrm { d i f f } } ( s , y ) = \\operatorname* { m a x } ( 0 , Q ( s , a ) - Q ( s , y ) ) , \\quad O v l ( s , y , \\epsilon ) = \\operatorname* { m a x } ( 0 , \\overline { { Q } } ( s , y , \\epsilon ) - \\underline { { Q } } ( s , a , \\epsilon ) + \\eta )", + "type": "interline_equation", + "image_path": "8d9b46786e65355b698ac95a9a7d933826cf416ff605fb04599ef28fddeefd7c.jpg" + } + ] + } + ], + "index": 35, + "virtual_lines": [ + { + "bbox": [ + 115, + 502, + 495, + 518 + ], + "spans": [], + "index": 35 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 524, + 505, + 591 + ], + "lines": [ + { + "bbox": [ + 106, + 524, + 506, + 537 + ], + "spans": [ + { + "bbox": [ + 106, + 524, + 186, + 537 + ], + "score": 0.91, + "content": "\\eta = 0 . 5 \\cdot Q _ { \\mathrm { d i f f } } ( s , y )", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 524, + 205, + 537 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 205, + 527, + 212, + 534 + ], + "score": 0.78, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 524, + 313, + 537 + ], + "score": 1.0, + "content": "is the action taken. Here", + "type": "text" + }, + { + "bbox": [ + 313, + 525, + 331, + 535 + ], + "score": 0.76, + "content": "O v l", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 524, + 506, + 537 + ], + "score": 1.0, + "content": "represents the overlap between the bounds", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 536, + 506, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 506, + 547 + ], + "score": 1.0, + "content": "of two actions (grey region in Fig 2). To promote additional robustness, the network is incentivized", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 546, + 506, + 559 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 176, + 559 + ], + "score": 1.0, + "content": "to have a margin", + "type": "text" + }, + { + "bbox": [ + 176, + 549, + 183, + 558 + ], + "score": 0.82, + "content": "\\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 546, + 349, + 559 + ], + "score": 1.0, + "content": "(rather than simply no overlaps). We set", + "type": "text" + }, + { + "bbox": [ + 350, + 547, + 408, + 558 + ], + "score": 0.91, + "content": "\\eta = 0 . 5 \\cdot Q _ { \\mathrm { d i f f } }", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 546, + 506, + 559 + ], + "score": 1.0, + "content": "to have it be half of the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 557, + 505, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 557, + 289, + 570 + ], + "score": 1.0, + "content": "maximum margin attainable. See Appendix", + "type": "text" + }, + { + "bbox": [ + 289, + 558, + 297, + 567 + ], + "score": 0.36, + "content": "\\mathrm { F }", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 557, + 505, + 570 + ], + "score": 1.0, + "content": "for experiments and discussion on the importance", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 567, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 252, + 581 + ], + "score": 1.0, + "content": "of this choice for margin. Note that", + "type": "text" + }, + { + "bbox": [ + 252, + 569, + 272, + 579 + ], + "score": 0.91, + "content": "Q _ { \\mathrm { d i f f } }", + "type": "inline_equation" + }, + { + "bbox": [ + 272, + 567, + 506, + 581 + ], + "score": 1.0, + "content": "is treated as a constant (no gradient) for the optimization.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 579, + 250, + 591 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 223, + 591 + ], + "score": 1.0, + "content": "Eq. (5) reduces to zero when", + "type": "text" + }, + { + "bbox": [ + 224, + 580, + 247, + 589 + ], + "score": 0.9, + "content": "\\epsilon = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 247, + 579, + 250, + 591 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 38.5 + }, + { + "type": "title", + "bbox": [ + 107, + 602, + 192, + 614 + ], + "lines": [ + { + "bbox": [ + 105, + 601, + 194, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 194, + 617 + ], + "score": 1.0, + "content": "3.2 RADIAL-A3C", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 106, + 622, + 506, + 699 + ], + "lines": [ + { + "bbox": [ + 105, + 622, + 506, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 233, + 636 + ], + "score": 1.0, + "content": "In A3C, as the value network", + "type": "text" + }, + { + "bbox": [ + 233, + 623, + 243, + 633 + ], + "score": 0.78, + "content": "V", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 622, + 297, + 636 + ], + "score": 1.0, + "content": "and entropy", + "type": "text" + }, + { + "bbox": [ + 297, + 623, + 307, + 633 + ], + "score": 0.82, + "content": "\\mathcal { H }", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 622, + 506, + 636 + ], + "score": 1.0, + "content": "are only used to help training, we will use the", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 633, + 506, + 646 + ], + "spans": [ + { + "bbox": [ + 106, + 634, + 315, + 646 + ], + "score": 1.0, + "content": "unperturbed form of the approximated advantage", + "type": "text" + }, + { + "bbox": [ + 316, + 633, + 380, + 646 + ], + "score": 0.92, + "content": "A _ { t } \\big ( s _ { t } , a _ { t } ; \\theta , \\theta _ { v } \\big )", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 634, + 435, + 646 + ], + "score": 1.0, + "content": "and entropy", + "type": "text" + }, + { + "bbox": [ + 436, + 634, + 446, + 644 + ], + "score": 0.77, + "content": "\\mathcal { H }", + "type": "inline_equation" + }, + { + "bbox": [ + 446, + 634, + 506, + 646 + ], + "score": 1.0, + "content": "and focus on", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 645, + 506, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 645, + 243, + 657 + ], + "score": 1.0, + "content": "designing a robust policy network", + "type": "text" + }, + { + "bbox": [ + 244, + 646, + 251, + 654 + ], + "score": 0.78, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 251, + 645, + 398, + 657 + ], + "score": 1.0, + "content": "in RADIAL-A3C. As the Approach", + "type": "text" + }, + { + "bbox": [ + 398, + 645, + 410, + 655 + ], + "score": 0.69, + "content": "\\# 2", + "type": "inline_equation" + }, + { + "bbox": [ + 410, + 645, + 506, + 657 + ], + "score": 1.0, + "content": "is more effective in our", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 656, + 506, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 656, + 299, + 668 + ], + "score": 1.0, + "content": "experiments, we focus on describing Approach", + "type": "text" + }, + { + "bbox": [ + 299, + 656, + 311, + 666 + ], + "score": 0.33, + "content": "\\# 2", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 656, + 495, + 668 + ], + "score": 1.0, + "content": "here and leave Approach #1 in the Appendix", + "type": "text" + }, + { + "bbox": [ + 495, + 656, + 503, + 666 + ], + "score": 0.28, + "content": "\\mathbf { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 503, + 656, + 506, + 668 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 666, + 506, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 194, + 679 + ], + "score": 1.0, + "content": "The idea of Approach", + "type": "text" + }, + { + "bbox": [ + 195, + 667, + 206, + 677 + ], + "score": 0.34, + "content": "\\# 2", + "type": "inline_equation" + }, + { + "bbox": [ + 207, + 666, + 397, + 679 + ], + "score": 1.0, + "content": "for A3C is very similar to DQN, except that the", + "type": "text" + }, + { + "bbox": [ + 397, + 667, + 406, + 678 + ], + "score": 0.53, + "content": "\\mathrm { Q }", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 666, + 506, + 679 + ], + "score": 1.0, + "content": "-values are replaced by a", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 678, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 678, + 244, + 690 + ], + "score": 1.0, + "content": "combination of the policy outputs", + "type": "text" + }, + { + "bbox": [ + 244, + 679, + 251, + 687 + ], + "score": 0.77, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 251, + 678, + 451, + 690 + ], + "score": 1.0, + "content": "and the pen-ultimate layer of the policy networks", + "type": "text" + }, + { + "bbox": [ + 451, + 679, + 458, + 687 + ], + "score": 0.76, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 678, + 505, + 690 + ], + "score": 1.0, + "content": "(before the", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 688, + 169, + 701 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 169, + 701 + ], + "score": 1.0, + "content": "softmax layer):", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 46 + }, + { + "type": "interline_equation", + "bbox": [ + 195, + 698, + 416, + 725 + ], + "lines": [ + { + "bbox": [ + 195, + 698, + 416, + 725 + ], + "spans": [ + { + "bbox": [ + 195, + 698, + 416, + 725 + ], + "score": 0.92, + "content": "\\mathcal { L } _ { \\mathrm { a d v } } ( \\theta _ { \\mathrm { a c t o r } } , \\epsilon ) = \\mathbb { E } _ { ( s , a , s ^ { \\prime } , r ) } [ \\sum _ { y } \\pi _ { \\mathrm { d i f f } } ( s , y ) \\cdot O v l ( s , y , \\epsilon ) ]", + "type": "interline_equation", + "image_path": "1340647e19c98aa79c844a77ed6f9d36272b17257f140baca08eb2fe1f8096ff.jpg" + } + ] + } + ], + "index": 50.5, + "virtual_lines": [ + { + "bbox": [ + 195, + 698, + 416, + 711.5 + ], + "spans": [], + "index": 50 + }, + { + "bbox": [ + 195, + 711.5, + 416, + 725.0 + ], + "spans": [], + "index": 51 + } + ] + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 740, + 309, + 753 + ], + "spans": [ + { + "bbox": [ + 302, + 740, + 309, + 753 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 72, + 504, + 95 + ], + "lines": [], + "index": 0.5, + "bbox_fs": [ + 106, + 73, + 505, + 96 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 99, + 505, + 253 + ], + "lines": [ + { + "bbox": [ + 105, + 100, + 505, + 112 + ], + "spans": [ + { + "bbox": [ + 105, + 100, + 271, + 112 + ], + "score": 1.0, + "content": "The foundation of both Approach #1 and", + "type": "text" + }, + { + "bbox": [ + 271, + 100, + 283, + 110 + ], + "score": 0.31, + "content": "\\# 2", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 100, + 505, + 112 + ], + "score": 1.0, + "content": "lies in the robustness formal verification tools to derive", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 111, + 506, + 123 + ], + "spans": [ + { + "bbox": [ + 105, + 111, + 506, + 123 + ], + "score": 1.0, + "content": "output bounds of neural networks under input perturbations. Specifically, for a given neural network,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 122, + 506, + 134 + ], + "spans": [ + { + "bbox": [ + 105, + 122, + 142, + 134 + ], + "score": 1.0, + "content": "suppose", + "type": "text" + }, + { + "bbox": [ + 142, + 122, + 165, + 134 + ], + "score": 0.92, + "content": "z _ { i } ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 122, + 263, + 134 + ], + "score": 1.0, + "content": "is the activation of the", + "type": "text" + }, + { + "bbox": [ + 264, + 123, + 268, + 132 + ], + "score": 0.27, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 122, + 432, + 134 + ], + "score": 1.0, + "content": "th layer of a neural network with input", + "type": "text" + }, + { + "bbox": [ + 433, + 124, + 439, + 132 + ], + "score": 0.76, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 439, + 122, + 506, + 134 + ], + "score": 1.0, + "content": ". The goal of a", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 132, + 505, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 505, + 145 + ], + "score": 1.0, + "content": "robustness verification algorithm is to compute layer-wise lower and upper bounds of the neural", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 143, + 506, + 156 + ], + "spans": [ + { + "bbox": [ + 104, + 143, + 187, + 156 + ], + "score": 1.0, + "content": "network, denoted as", + "type": "text" + }, + { + "bbox": [ + 188, + 144, + 219, + 156 + ], + "score": 0.92, + "content": "\\underline { { z } } _ { i } ( x , \\epsilon )", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 143, + 237, + 156 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 238, + 144, + 269, + 155 + ], + "score": 0.91, + "content": "\\overline { { z } } _ { i } ( x , \\epsilon )", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 143, + 311, + 156 + ], + "score": 1.0, + "content": ", such that", + "type": "text" + }, + { + "bbox": [ + 311, + 144, + 437, + 156 + ], + "score": 0.93, + "content": "\\underline { { z } } _ { i } ( x , \\epsilon ) \\leq z _ { i } ( x + \\delta ) \\leq \\overline { { z _ { i } } } ( x , \\epsilon )", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 143, + 506, + 156 + ], + "score": 1.0, + "content": ", for any additive", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 154, + 506, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 182, + 167 + ], + "score": 1.0, + "content": "input perturbation", + "type": "text" + }, + { + "bbox": [ + 183, + 155, + 189, + 164 + ], + "score": 0.79, + "content": "\\delta", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 154, + 203, + 167 + ], + "score": 1.0, + "content": "on", + "type": "text" + }, + { + "bbox": [ + 203, + 157, + 210, + 164 + ], + "score": 0.8, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 154, + 232, + 167 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 232, + 155, + 272, + 167 + ], + "score": 0.91, + "content": "| | \\delta | | _ { p } \\leq \\epsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 272, + 154, + 506, + 167 + ], + "score": 1.0, + "content": ". We will apply robustness verification algorithms on the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 165, + 504, + 178 + ], + "spans": [ + { + "bbox": [ + 106, + 165, + 495, + 178 + ], + "score": 1.0, + "content": "Q-networks (for DQN) or policy networks (for A3C and PPO) to get layer-wise output bounds of", + "type": "text" + }, + { + "bbox": [ + 495, + 166, + 504, + 177 + ], + "score": 0.84, + "content": "Q", + "type": "inline_equation" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 176, + 506, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 123, + 190 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 124, + 178, + 131, + 186 + ], + "score": 0.75, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 131, + 176, + 506, + 190 + ], + "score": 1.0, + "content": ". These output bounds can be used to calculate an upper bound of the original loss function", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 187, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 106, + 187, + 275, + 200 + ], + "score": 1.0, + "content": "under worst-case adversarial perturbation", + "type": "text" + }, + { + "bbox": [ + 276, + 187, + 294, + 198 + ], + "score": 0.9, + "content": "{ \\mathcal { L } } _ { \\mathrm { a d v } }", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 187, + 505, + 200 + ], + "score": 1.0, + "content": "for Approach #1. Similarly, the layer-wise bound is", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 198, + 506, + 211 + ], + "spans": [ + { + "bbox": [ + 106, + 198, + 410, + 211 + ], + "score": 1.0, + "content": "used to minimize the overlap of output intervals as proposed in Approach", + "type": "text" + }, + { + "bbox": [ + 410, + 198, + 422, + 208 + ], + "score": 0.32, + "content": "\\# 2", + "type": "inline_equation" + }, + { + "bbox": [ + 422, + 198, + 506, + 211 + ], + "score": 1.0, + "content": ". For the purpose of", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 209, + 506, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 209, + 506, + 222 + ], + "score": 1.0, + "content": "training efficiency, IBP [14] is used to compute the layer-wise bounds for the neural networks, but", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 219, + 505, + 232 + ], + "spans": [ + { + "bbox": [ + 105, + 219, + 505, + 232 + ], + "score": 1.0, + "content": "other differentiable certification methods [12, 13, 11, 31, 32, 33] could be applied directly (albeit", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 231, + 505, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 369, + 244 + ], + "score": 1.0, + "content": "may incur additional computation cost). Our experiments focus on", + "type": "text" + }, + { + "bbox": [ + 370, + 232, + 399, + 243 + ], + "score": 0.9, + "content": "p = \\infty", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 231, + 505, + 244 + ], + "score": 1.0, + "content": "to compare with baselines", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 241, + 274, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 264, + 255 + ], + "score": 1.0, + "content": "but the methodology works for general", + "type": "text" + }, + { + "bbox": [ + 264, + 244, + 270, + 253 + ], + "score": 0.79, + "content": "p", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 241, + 274, + 255 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 8.5, + "bbox_fs": [ + 104, + 100, + 506, + 255 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 264, + 195, + 277 + ], + "lines": [ + { + "bbox": [ + 104, + 263, + 197, + 281 + ], + "spans": [ + { + "bbox": [ + 104, + 263, + 197, + 281 + ], + "score": 1.0, + "content": "3.1 RADIAL-DQN", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 285, + 505, + 355 + ], + "lines": [ + { + "bbox": [ + 105, + 285, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 279, + 298 + ], + "score": 1.0, + "content": "For Dueling-DQN, the advantage function", + "type": "text" + }, + { + "bbox": [ + 280, + 286, + 295, + 298 + ], + "score": 0.9, + "content": "A _ { Q }", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 285, + 505, + 298 + ], + "score": 1.0, + "content": "is used to decide which action to take and the value", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 296, + 505, + 309 + ], + "spans": [ + { + "bbox": [ + 106, + 296, + 141, + 309 + ], + "score": 1.0, + "content": "function", + "type": "text" + }, + { + "bbox": [ + 141, + 297, + 155, + 309 + ], + "score": 0.89, + "content": "V _ { Q }", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 296, + 388, + 309 + ], + "score": 1.0, + "content": "is only important for training. Hence, we only need to make", + "type": "text" + }, + { + "bbox": [ + 389, + 297, + 403, + 308 + ], + "score": 0.89, + "content": "A _ { Q }", + "type": "inline_equation" + }, + { + "bbox": [ + 404, + 296, + 505, + 309 + ], + "score": 1.0, + "content": "robust and the Q function", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 104, + 307, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 104, + 307, + 226, + 323 + ], + "score": 1.0, + "content": "is lower and upper bounded by", + "type": "text" + }, + { + "bbox": [ + 226, + 308, + 357, + 322 + ], + "score": 0.91, + "content": "\\underline { { Q } } ( s , a , \\epsilon ) = V _ { Q } ( s ) + \\underline { { A _ { Q } } } ( s , a , \\epsilon )", + "type": "inline_equation" + }, + { + "bbox": [ + 358, + 307, + 374, + 323 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 374, + 308, + 505, + 321 + ], + "score": 0.92, + "content": "\\overline { { { Q } } } ( s , a , \\epsilon ) = V _ { Q } ( s ) + \\overline { { { A _ { Q } } } } ( s , a , \\epsilon )", + "type": "inline_equation" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 321, + 505, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 321, + 127, + 335 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 127, + 324, + 132, + 331 + ], + "score": 0.74, + "content": "\\epsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 321, + 264, + 335 + ], + "score": 1.0, + "content": "-bounded perturbations to input", + "type": "text" + }, + { + "bbox": [ + 264, + 324, + 270, + 331 + ], + "score": 0.68, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 321, + 505, + 335 + ], + "score": 1.0, + "content": ". In RADIAL we proposde two approaches to derive the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 332, + 506, + 346 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 170, + 346 + ], + "score": 1.0, + "content": "adversarial loss", + "type": "text" + }, + { + "bbox": [ + 170, + 333, + 189, + 344 + ], + "score": 0.89, + "content": "{ \\mathcal { L } } _ { \\mathrm { a d v } }", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 332, + 506, + 346 + ], + "score": 1.0, + "content": "; however, due to the space constraints, we describe the approach that has better", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 344, + 413, + 356 + ], + "spans": [ + { + "bbox": [ + 106, + 344, + 413, + 356 + ], + "score": 1.0, + "content": "empirical performance in the main text, and leave the other in the Appendix.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 19.5, + "bbox_fs": [ + 104, + 285, + 506, + 356 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 359, + 505, + 448 + ], + "lines": [ + { + "bbox": [ + 106, + 360, + 505, + 372 + ], + "spans": [ + { + "bbox": [ + 106, + 360, + 243, + 372 + ], + "score": 1.0, + "content": "For DQN, we find that Approach", + "type": "text" + }, + { + "bbox": [ + 244, + 360, + 255, + 370 + ], + "score": 0.26, + "content": "\\# 2", + "type": "inline_equation" + }, + { + "bbox": [ + 256, + 360, + 505, + 372 + ], + "score": 1.0, + "content": "performs better. The goal of Approach #2 is to minimize the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 371, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 106, + 371, + 505, + 383 + ], + "score": 1.0, + "content": "weighted overlap of activation bounds for different actions (Fig. 2). The idea is to minimize only", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 382, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 382, + 505, + 394 + ], + "score": 1.0, + "content": "what is necessary for robust performance, overlap. If there is no overlap, the original action’s Q-value", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 393, + 505, + 405 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 505, + 405 + ], + "score": 1.0, + "content": "is guaranteed to be higher than others even under perturbation, so the agent won’t change it’s behavior", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 404, + 506, + 416 + ], + "spans": [ + { + "bbox": [ + 106, + 404, + 506, + 416 + ], + "score": 1.0, + "content": "under perturbation. However not all overlap is equally important. If two actions have a very similar", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 415, + 506, + 427 + ], + "spans": [ + { + "bbox": [ + 106, + 415, + 115, + 426 + ], + "score": 0.25, + "content": "\\mathrm { Q }", + "type": "inline_equation" + }, + { + "bbox": [ + 115, + 415, + 506, + 427 + ], + "score": 1.0, + "content": "-value, overlap is acceptable, as taking a different but equally good action under perturbation is not", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 104, + 425, + 506, + 438 + ], + "spans": [ + { + "bbox": [ + 104, + 425, + 311, + 438 + ], + "score": 1.0, + "content": "a problem. To address this we added weighting by", + "type": "text" + }, + { + "bbox": [ + 312, + 425, + 331, + 437 + ], + "score": 0.91, + "content": "Q _ { \\mathrm { d i f f } }", + "type": "inline_equation" + }, + { + "bbox": [ + 332, + 425, + 506, + 438 + ], + "score": 1.0, + "content": ", which helps by multiplying overlaps with", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 435, + 475, + 450 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 475, + 450 + ], + "score": 1.0, + "content": "similar Q-values by a small number and overlaps with different Q-values by a large number.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 26.5, + "bbox_fs": [ + 104, + 360, + 506, + 450 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 452, + 270, + 464 + ], + "lines": [ + { + "bbox": [ + 106, + 451, + 271, + 465 + ], + "spans": [ + { + "bbox": [ + 106, + 451, + 271, + 465 + ], + "score": 1.0, + "content": "The final loss loss function is as follows:", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31, + "bbox_fs": [ + 106, + 451, + 271, + 465 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 194, + 462, + 417, + 489 + ], + "lines": [ + { + "bbox": [ + 194, + 462, + 417, + 489 + ], + "spans": [ + { + "bbox": [ + 194, + 462, + 417, + 489 + ], + "score": 0.93, + "content": "\\mathcal { L } _ { \\mathrm { a d v } } ( \\theta _ { \\mathrm { a c t o r } } , \\epsilon ) = \\mathbb { E } _ { ( s , a , s ^ { \\prime } , r ) } [ \\sum _ { y } Q _ { \\mathrm { d i f f } } ( s , y ) \\cdot O v l ( s , y , \\epsilon ) ]", + "type": "interline_equation", + "image_path": "33c317fca69d8030101ff07179f67cd136e0e6baf7037510f03ea4b73724c03d.jpg" + } + ] + } + ], + "index": 32.5, + "virtual_lines": [ + { + "bbox": [ + 194, + 462, + 417, + 475.5 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 194, + 475.5, + 417, + 489.0 + ], + "spans": [], + "index": 33 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 491, + 132, + 501 + ], + "lines": [ + { + "bbox": [ + 105, + 489, + 135, + 503 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 135, + 503 + ], + "score": 1.0, + "content": "where", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34, + "bbox_fs": [ + 105, + 489, + 135, + 503 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 115, + 502, + 495, + 518 + ], + "lines": [ + { + "bbox": [ + 115, + 502, + 495, + 518 + ], + "spans": [ + { + "bbox": [ + 115, + 502, + 495, + 518 + ], + "score": 0.9, + "content": "Q _ { \\mathrm { d i f f } } ( s , y ) = \\operatorname* { m a x } ( 0 , Q ( s , a ) - Q ( s , y ) ) , \\quad O v l ( s , y , \\epsilon ) = \\operatorname* { m a x } ( 0 , \\overline { { Q } } ( s , y , \\epsilon ) - \\underline { { Q } } ( s , a , \\epsilon ) + \\eta )", + "type": "interline_equation", + "image_path": "8d9b46786e65355b698ac95a9a7d933826cf416ff605fb04599ef28fddeefd7c.jpg" + } + ] + } + ], + "index": 35, + "virtual_lines": [ + { + "bbox": [ + 115, + 502, + 495, + 518 + ], + "spans": [], + "index": 35 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 524, + 505, + 591 + ], + "lines": [ + { + "bbox": [ + 106, + 524, + 506, + 537 + ], + "spans": [ + { + "bbox": [ + 106, + 524, + 186, + 537 + ], + "score": 0.91, + "content": "\\eta = 0 . 5 \\cdot Q _ { \\mathrm { d i f f } } ( s , y )", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 524, + 205, + 537 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 205, + 527, + 212, + 534 + ], + "score": 0.78, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 524, + 313, + 537 + ], + "score": 1.0, + "content": "is the action taken. Here", + "type": "text" + }, + { + "bbox": [ + 313, + 525, + 331, + 535 + ], + "score": 0.76, + "content": "O v l", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 524, + 506, + 537 + ], + "score": 1.0, + "content": "represents the overlap between the bounds", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 536, + 506, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 506, + 547 + ], + "score": 1.0, + "content": "of two actions (grey region in Fig 2). To promote additional robustness, the network is incentivized", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 546, + 506, + 559 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 176, + 559 + ], + "score": 1.0, + "content": "to have a margin", + "type": "text" + }, + { + "bbox": [ + 176, + 549, + 183, + 558 + ], + "score": 0.82, + "content": "\\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 546, + 349, + 559 + ], + "score": 1.0, + "content": "(rather than simply no overlaps). We set", + "type": "text" + }, + { + "bbox": [ + 350, + 547, + 408, + 558 + ], + "score": 0.91, + "content": "\\eta = 0 . 5 \\cdot Q _ { \\mathrm { d i f f } }", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 546, + 506, + 559 + ], + "score": 1.0, + "content": "to have it be half of the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 557, + 505, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 557, + 289, + 570 + ], + "score": 1.0, + "content": "maximum margin attainable. See Appendix", + "type": "text" + }, + { + "bbox": [ + 289, + 558, + 297, + 567 + ], + "score": 0.36, + "content": "\\mathrm { F }", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 557, + 505, + 570 + ], + "score": 1.0, + "content": "for experiments and discussion on the importance", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 567, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 252, + 581 + ], + "score": 1.0, + "content": "of this choice for margin. Note that", + "type": "text" + }, + { + "bbox": [ + 252, + 569, + 272, + 579 + ], + "score": 0.91, + "content": "Q _ { \\mathrm { d i f f } }", + "type": "inline_equation" + }, + { + "bbox": [ + 272, + 567, + 506, + 581 + ], + "score": 1.0, + "content": "is treated as a constant (no gradient) for the optimization.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 579, + 250, + 591 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 223, + 591 + ], + "score": 1.0, + "content": "Eq. (5) reduces to zero when", + "type": "text" + }, + { + "bbox": [ + 224, + 580, + 247, + 589 + ], + "score": 0.9, + "content": "\\epsilon = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 247, + 579, + 250, + 591 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 38.5, + "bbox_fs": [ + 105, + 524, + 506, + 591 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 602, + 192, + 614 + ], + "lines": [ + { + "bbox": [ + 105, + 601, + 194, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 194, + 617 + ], + "score": 1.0, + "content": "3.2 RADIAL-A3C", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 106, + 622, + 506, + 699 + ], + "lines": [ + { + "bbox": [ + 105, + 622, + 506, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 233, + 636 + ], + "score": 1.0, + "content": "In A3C, as the value network", + "type": "text" + }, + { + "bbox": [ + 233, + 623, + 243, + 633 + ], + "score": 0.78, + "content": "V", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 622, + 297, + 636 + ], + "score": 1.0, + "content": "and entropy", + "type": "text" + }, + { + "bbox": [ + 297, + 623, + 307, + 633 + ], + "score": 0.82, + "content": "\\mathcal { H }", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 622, + 506, + 636 + ], + "score": 1.0, + "content": "are only used to help training, we will use the", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 633, + 506, + 646 + ], + "spans": [ + { + "bbox": [ + 106, + 634, + 315, + 646 + ], + "score": 1.0, + "content": "unperturbed form of the approximated advantage", + "type": "text" + }, + { + "bbox": [ + 316, + 633, + 380, + 646 + ], + "score": 0.92, + "content": "A _ { t } \\big ( s _ { t } , a _ { t } ; \\theta , \\theta _ { v } \\big )", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 634, + 435, + 646 + ], + "score": 1.0, + "content": "and entropy", + "type": "text" + }, + { + "bbox": [ + 436, + 634, + 446, + 644 + ], + "score": 0.77, + "content": "\\mathcal { H }", + "type": "inline_equation" + }, + { + "bbox": [ + 446, + 634, + 506, + 646 + ], + "score": 1.0, + "content": "and focus on", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 645, + 506, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 645, + 243, + 657 + ], + "score": 1.0, + "content": "designing a robust policy network", + "type": "text" + }, + { + "bbox": [ + 244, + 646, + 251, + 654 + ], + "score": 0.78, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 251, + 645, + 398, + 657 + ], + "score": 1.0, + "content": "in RADIAL-A3C. As the Approach", + "type": "text" + }, + { + "bbox": [ + 398, + 645, + 410, + 655 + ], + "score": 0.69, + "content": "\\# 2", + "type": "inline_equation" + }, + { + "bbox": [ + 410, + 645, + 506, + 657 + ], + "score": 1.0, + "content": "is more effective in our", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 656, + 506, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 656, + 299, + 668 + ], + "score": 1.0, + "content": "experiments, we focus on describing Approach", + "type": "text" + }, + { + "bbox": [ + 299, + 656, + 311, + 666 + ], + "score": 0.33, + "content": "\\# 2", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 656, + 495, + 668 + ], + "score": 1.0, + "content": "here and leave Approach #1 in the Appendix", + "type": "text" + }, + { + "bbox": [ + 495, + 656, + 503, + 666 + ], + "score": 0.28, + "content": "\\mathbf { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 503, + 656, + 506, + 668 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 666, + 506, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 194, + 679 + ], + "score": 1.0, + "content": "The idea of Approach", + "type": "text" + }, + { + "bbox": [ + 195, + 667, + 206, + 677 + ], + "score": 0.34, + "content": "\\# 2", + "type": "inline_equation" + }, + { + "bbox": [ + 207, + 666, + 397, + 679 + ], + "score": 1.0, + "content": "for A3C is very similar to DQN, except that the", + "type": "text" + }, + { + "bbox": [ + 397, + 667, + 406, + 678 + ], + "score": 0.53, + "content": "\\mathrm { Q }", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 666, + 506, + 679 + ], + "score": 1.0, + "content": "-values are replaced by a", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 678, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 678, + 244, + 690 + ], + "score": 1.0, + "content": "combination of the policy outputs", + "type": "text" + }, + { + "bbox": [ + 244, + 679, + 251, + 687 + ], + "score": 0.77, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 251, + 678, + 451, + 690 + ], + "score": 1.0, + "content": "and the pen-ultimate layer of the policy networks", + "type": "text" + }, + { + "bbox": [ + 451, + 679, + 458, + 687 + ], + "score": 0.76, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 678, + 505, + 690 + ], + "score": 1.0, + "content": "(before the", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 688, + 169, + 701 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 169, + 701 + ], + "score": 1.0, + "content": "softmax layer):", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 46, + "bbox_fs": [ + 105, + 622, + 506, + 701 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 195, + 698, + 416, + 725 + ], + "lines": [ + { + "bbox": [ + 195, + 698, + 416, + 725 + ], + "spans": [ + { + "bbox": [ + 195, + 698, + 416, + 725 + ], + "score": 0.92, + "content": "\\mathcal { L } _ { \\mathrm { a d v } } ( \\theta _ { \\mathrm { a c t o r } } , \\epsilon ) = \\mathbb { E } _ { ( s , a , s ^ { \\prime } , r ) } [ \\sum _ { y } \\pi _ { \\mathrm { d i f f } } ( s , y ) \\cdot O v l ( s , y , \\epsilon ) ]", + "type": "interline_equation", + "image_path": "1340647e19c98aa79c844a77ed6f9d36272b17257f140baca08eb2fe1f8096ff.jpg" + } + ] + } + ], + "index": 50.5, + "virtual_lines": [ + { + "bbox": [ + 195, + 698, + 416, + 711.5 + ], + "spans": [], + "index": 50 + }, + { + "bbox": [ + 195, + 711.5, + 416, + 725.0 + ], + "spans": [], + "index": 51 + } + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 114, + 78, + 284, + 219 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 114, + 78, + 284, + 219 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 114, + 78, + 284, + 219 + ], + "spans": [ + { + "bbox": [ + 114, + 78, + 284, + 219 + ], + "score": 0.952, + "type": "image", + "image_path": "6c9e9d36358ef5d3e304ac88c13e30f6b9509dfe8e774585db0bf8244ffaad53.jpg" + } + ] + } + ], + "index": 4.5, + "virtual_lines": [ + { + "bbox": [ + 114, + 78, + 284, + 92.1 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 114, + 92.1, + 284, + 106.19999999999999 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 114, + 106.19999999999999, + 284, + 120.29999999999998 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 114, + 120.29999999999998, + 284, + 134.39999999999998 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 114, + 134.39999999999998, + 284, + 148.49999999999997 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 114, + 148.49999999999997, + 284, + 162.59999999999997 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 114, + 162.59999999999997, + 284, + 176.69999999999996 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 114, + 176.69999999999996, + 284, + 190.79999999999995 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 114, + 190.79999999999995, + 284, + 204.89999999999995 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 114, + 204.89999999999995, + 284, + 218.99999999999994 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 232, + 307, + 255 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 232, + 307, + 245 + ], + "spans": [ + { + "bbox": [ + 106, + 232, + 202, + 245 + ], + "score": 1.0, + "content": "Figure 2: Visualizing", + "type": "text" + }, + { + "bbox": [ + 202, + 233, + 221, + 244 + ], + "score": 0.9, + "content": "L _ { \\mathrm { a d v } }", + "type": "inline_equation" + }, + { + "bbox": [ + 221, + 232, + 307, + 245 + ], + "score": 1.0, + "content": "for RADIAL-DQN", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 243, + 294, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 294, + 255 + ], + "score": 1.0, + "content": "(Approach #2) in a simple case with 2 actions.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5 + } + ], + "index": 7.5 + }, + { + "type": "title", + "bbox": [ + 321, + 87, + 489, + 98 + ], + "lines": [ + { + "bbox": [ + 320, + 86, + 490, + 100 + ], + "spans": [ + { + "bbox": [ + 320, + 86, + 490, + 100 + ], + "score": 1.0, + "content": "Algorithm 1: Greedy Worst-Case Reward", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 320, + 101, + 491, + 241 + ], + "lines": [ + { + "bbox": [ + 320, + 98, + 349, + 112 + ], + "spans": [ + { + "bbox": [ + 320, + 98, + 348, + 110 + ], + "score": 0.33, + "content": "\\overline { { R = 0 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 348, + 99, + 349, + 112 + ], + "score": 0.0, + "content": "", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 320, + 111, + 420, + 122 + ], + "spans": [ + { + "bbox": [ + 320, + 111, + 345, + 122 + ], + "score": 1.0, + "content": "while", + "type": "text" + }, + { + "bbox": [ + 345, + 113, + 354, + 122 + ], + "score": 0.81, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 355, + 111, + 420, + 122 + ], + "score": 1.0, + "content": "not terminal do", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 334, + 120, + 488, + 135 + ], + "spans": [ + { + "bbox": [ + 334, + 120, + 385, + 135 + ], + "score": 1.0, + "content": "1. Calculate", + "type": "text" + }, + { + "bbox": [ + 386, + 122, + 421, + 133 + ], + "score": 0.9, + "content": "\\pi _ { i } ( s _ { t } , \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 421, + 120, + 425, + 135 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 425, + 122, + 469, + 134 + ], + "score": 0.89, + "content": "\\underline { { \\pi } } _ { i } ( s _ { t } , \\epsilon ; \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 469, + 120, + 488, + 135 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 340, + 132, + 453, + 145 + ], + "spans": [ + { + "bbox": [ + 340, + 133, + 385, + 144 + ], + "score": 0.9, + "content": "\\overline { { \\pi } } _ { i } ( s _ { t } , \\epsilon ; \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 132, + 448, + 145 + ], + "score": 1.0, + "content": "for each action", + "type": "text" + }, + { + "bbox": [ + 448, + 134, + 453, + 142 + ], + "score": 0.64, + "content": "i", + "type": "inline_equation" + } + ], + "index": 16 + }, + { + "bbox": [ + 335, + 142, + 477, + 155 + ], + "spans": [ + { + "bbox": [ + 335, + 142, + 477, + 155 + ], + "score": 1.0, + "content": "2. Calculate set of possible actions", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 340, + 154, + 449, + 168 + ], + "spans": [ + { + "bbox": [ + 340, + 154, + 449, + 168 + ], + "score": 0.8, + "content": "\\Gamma : = \\{ i | \\overline { { \\pi } } _ { i } \\geq \\operatorname* { m a x } _ { j } ( \\underline { { \\pi } } _ { j } ) \\}", + "type": "inline_equation" + } + ], + "index": 18 + }, + { + "bbox": [ + 335, + 164, + 490, + 176 + ], + "spans": [ + { + "bbox": [ + 335, + 164, + 441, + 176 + ], + "score": 1.0, + "content": "3. Take the \"worst\" action", + "type": "text" + }, + { + "bbox": [ + 442, + 167, + 448, + 175 + ], + "score": 0.79, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 164, + 490, + 176 + ], + "score": 1.0, + "content": "out of the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 340, + 176, + 409, + 188 + ], + "spans": [ + { + "bbox": [ + 340, + 176, + 409, + 188 + ], + "score": 1.0, + "content": "possible actions,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 340, + 186, + 485, + 201 + ], + "spans": [ + { + "bbox": [ + 340, + 187, + 444, + 200 + ], + "score": 0.88, + "content": "k = \\mathrm { a r g m i n } _ { i \\in \\Gamma } ( \\pi _ { i } ( s _ { t } , \\theta ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 186, + 485, + 201 + ], + "score": 1.0, + "content": ". Observe", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 340, + 198, + 487, + 210 + ], + "spans": [ + { + "bbox": [ + 340, + 200, + 350, + 209 + ], + "score": 0.8, + "content": "r _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 350, + 198, + 368, + 210 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 368, + 200, + 387, + 210 + ], + "score": 0.87, + "content": "s _ { t + 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 198, + 435, + 210 + ], + "score": 1.0, + "content": "and update", + "type": "text" + }, + { + "bbox": [ + 435, + 199, + 487, + 209 + ], + "score": 0.9, + "content": "R \\gets R + r _ { t }", + "type": "inline_equation" + } + ], + "index": 22 + }, + { + "bbox": [ + 334, + 208, + 385, + 221 + ], + "spans": [ + { + "bbox": [ + 334, + 208, + 345, + 221 + ], + "score": 1.0, + "content": "4.", + "type": "text" + }, + { + "bbox": [ + 345, + 210, + 385, + 219 + ], + "score": 0.72, + "content": "t = t + 1", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 319, + 218, + 340, + 230 + ], + "spans": [ + { + "bbox": [ + 319, + 218, + 340, + 230 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 319, + 229, + 360, + 240 + ], + "spans": [ + { + "bbox": [ + 319, + 229, + 350, + 240 + ], + "score": 1.0, + "content": "return", + "type": "text" + }, + { + "bbox": [ + 350, + 230, + 360, + 240 + ], + "score": 0.61, + "content": "R", + "type": "inline_equation" + } + ], + "index": 25 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 106, + 275, + 505, + 299 + ], + "lines": [ + { + "bbox": [ + 105, + 273, + 503, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 126, + 289 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 127, + 275, + 285, + 287 + ], + "score": 0.9, + "content": "\\pi _ { \\operatorname { d i f f } } ( s , y ) = \\operatorname* { m a x } ( 0 , \\pi ( s , a ) - \\pi ( s , y ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 273, + 304, + 289 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 304, + 275, + 503, + 288 + ], + "score": 0.82, + "content": "O v l ( s , y , \\epsilon ) = \\operatorname* { m a x } ( 0 , \\overline { { z } } ( s , y , \\epsilon ) - \\underline { { z } } ( s , a , \\epsilon ) + \\eta )", + "type": "inline_equation" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 284, + 388, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 135, + 300 + ], + "score": 1.0, + "content": "Where", + "type": "text" + }, + { + "bbox": [ + 135, + 287, + 212, + 299 + ], + "score": 0.9, + "content": "\\eta = 0 . 5 \\cdot z _ { \\mathrm { d i f f } } ( s , y )", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 284, + 230, + 300 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 230, + 287, + 383, + 299 + ], + "score": 0.9, + "content": "z _ { \\mathrm { d i f f } } ( s , y ) = \\operatorname* { m a x } ( 0 , z ( s , a ) - z ( s , y ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 284, + 388, + 300 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5 + }, + { + "type": "title", + "bbox": [ + 107, + 310, + 194, + 322 + ], + "lines": [ + { + "bbox": [ + 105, + 309, + 194, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 194, + 325 + ], + "score": 1.0, + "content": "3.3 RADIAL-PPO", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 106, + 331, + 505, + 386 + ], + "lines": [ + { + "bbox": [ + 105, + 330, + 507, + 344 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 344, + 344 + ], + "score": 1.0, + "content": "For RADIAL-PPO, we use Approach #1 as Approach", + "type": "text" + }, + { + "bbox": [ + 345, + 331, + 357, + 341 + ], + "score": 0.51, + "content": "\\# 2", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 330, + 507, + 344 + ], + "score": 1.0, + "content": "does not work for continuous ac-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 341, + 505, + 355 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 505, + 355 + ], + "score": 1.0, + "content": "tions(discussion in Appendix C). In RADIAL-PPO, we only calculate bounds over current policy", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 353, + 505, + 366 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 505, + 366 + ], + "score": 1.0, + "content": "output, because the experiences are generated by sampling from unperturbed old policy, and value", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 362, + 506, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 506, + 377 + ], + "score": 1.0, + "content": "function/advantage are only used during training. The intuition for Approach #1 is to derive an upper", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 374, + 318, + 387 + ], + "spans": [ + { + "bbox": [ + 106, + 374, + 318, + 387 + ], + "score": 1.0, + "content": "bound of the RHS of Eqn. 3 which will always hold.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 106, + 390, + 505, + 435 + ], + "lines": [ + { + "bbox": [ + 106, + 389, + 506, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 317, + 403 + ], + "score": 0.87, + "content": "\\forall s _ { t } \\in S , \\forall | | \\delta | | _ { p } \\leq \\epsilon \\ ; \\mathcal { L } ( \\theta , s _ { t } + \\delta ) \\leq \\mathcal { L } _ { \\mathrm { a d v } } ( \\theta , s _ { t } , \\epsilon )", + "type": "inline_equation" + }, + { + "bbox": [ + 318, + 389, + 506, + 404 + ], + "score": 1.0, + "content": ". Minimizing this upper bound will then also", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "score": 1.0, + "content": "decrease the loss under perturbation. In practice optimizing this loss function results in increasing the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 412, + 507, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 325, + 426 + ], + "score": 1.0, + "content": "lower bound of the probability of taking good actions", + "type": "text" + }, + { + "bbox": [ + 326, + 413, + 358, + 424 + ], + "score": 0.88, + "content": "( A _ { t } \\geq 0 )", + "type": "inline_equation" + }, + { + "bbox": [ + 358, + 412, + 507, + 426 + ], + "score": 1.0, + "content": "), and decreasing the upper bound of", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 424, + 284, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 424, + 246, + 435 + ], + "score": 1.0, + "content": "the probability to take bad actions", + "type": "text" + }, + { + "bbox": [ + 246, + 424, + 279, + 435 + ], + "score": 0.88, + "content": "( A _ { t } < 0 )", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 424, + 284, + 435 + ], + "score": 1.0, + "content": ").", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 107, + 439, + 319, + 452 + ], + "lines": [ + { + "bbox": [ + 105, + 437, + 320, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 232, + 454 + ], + "score": 1.0, + "content": "The mathematical definition of", + "type": "text" + }, + { + "bbox": [ + 232, + 441, + 250, + 451 + ], + "score": 0.91, + "content": "{ \\mathcal { L } } _ { \\mathrm { a d v } }", + "type": "inline_equation" + }, + { + "bbox": [ + 251, + 437, + 320, + 454 + ], + "score": 1.0, + "content": "is the following:", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + }, + { + "type": "interline_equation", + "bbox": [ + 129, + 456, + 480, + 483 + ], + "lines": [ + { + "bbox": [ + 129, + 456, + 480, + 483 + ], + "spans": [ + { + "bbox": [ + 129, + 456, + 480, + 483 + ], + "score": 0.92, + "content": "\\mathcal { L } _ { \\mathrm { a d v } } ( \\theta , \\epsilon ) = \\mathbb { E } _ { ( s _ { t } , a _ { t } , r _ { t } ) } \\left[ - \\operatorname* { m i n } ( \\frac { \\hat { \\pi } ( a _ { t } | s _ { t } , \\epsilon ; \\theta ) } { \\pi ( a _ { t } | s _ { t } ; \\theta _ { \\mathrm { o l d } } ) } A _ { t } , \\mathrm { c l i p } ( \\frac { \\hat { \\pi } ( a _ { t } | s _ { t } , \\epsilon ; \\theta ) } { \\pi ( a _ { t } | s _ { t } ; \\theta _ { \\mathrm { o l d } } ) } , 1 - \\eta , 1 + \\eta ) A _ { t } ) \\right] .", + "type": "interline_equation", + "image_path": "a65430ac47d8d19456c9232e2055935426825b5e86ec57fb3f48aeae22d72438.jpg" + } + ] + } + ], + "index": 39, + "virtual_lines": [ + { + "bbox": [ + 129, + 456, + 480, + 483 + ], + "spans": [], + "index": 39 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 492, + 250, + 504 + ], + "lines": [ + { + "bbox": [ + 106, + 492, + 251, + 506 + ], + "spans": [ + { + "bbox": [ + 106, + 492, + 251, + 506 + ], + "score": 1.0, + "content": "The worst-case policy is defined as:", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "interline_equation", + "bbox": [ + 216, + 509, + 394, + 537 + ], + "lines": [ + { + "bbox": [ + 216, + 509, + 394, + 537 + ], + "spans": [ + { + "bbox": [ + 216, + 509, + 394, + 537 + ], + "score": 0.93, + "content": "\\hat { \\pi } ( a _ { t } | s _ { t } , \\epsilon ; \\theta ) = \\left\\{ \\frac { \\pi ( a _ { t } | s _ { t } , \\epsilon ; \\theta ) , \\ \\mathrm { i f } \\ A _ { t } \\geq 0 } { \\pi ( a _ { t } | s _ { t } , \\epsilon ; \\theta ) , \\ \\mathrm { o t h e r w i s e } } \\right.", + "type": "interline_equation", + "image_path": "0c60b2a8549c800f95ec7f3bb3600df305f8ffa629996b2c38a6ed507962e41c.jpg" + } + ] + } + ], + "index": 41, + "virtual_lines": [ + { + "bbox": [ + 216, + 509, + 394, + 537 + ], + "spans": [], + "index": 41 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 547, + 505, + 570 + ], + "lines": [ + { + "bbox": [ + 106, + 547, + 506, + 560 + ], + "spans": [ + { + "bbox": [ + 106, + 547, + 429, + 560 + ], + "score": 1.0, + "content": "For our continuous control experiments, the output of our policy are the parameters", + "type": "text" + }, + { + "bbox": [ + 429, + 548, + 448, + 559 + ], + "score": 0.9, + "content": "\\mu , \\Sigma", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 547, + 506, + 560 + ], + "score": 1.0, + "content": "of a Gaussian,", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 558, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 351, + 570 + ], + "score": 1.0, + "content": "with covariance being diagonal and independent of input state", + "type": "text" + }, + { + "bbox": [ + 351, + 560, + 357, + 568 + ], + "score": 0.67, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 558, + 496, + 570 + ], + "score": 1.0, + "content": ". We can define bounds on distance", + "type": "text" + }, + { + "bbox": [ + 496, + 559, + 502, + 568 + ], + "score": 0.82, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 503, + 558, + 506, + 570 + ], + "score": 1.0, + "content": ":", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5 + }, + { + "type": "text", + "bbox": [ + 106, + 573, + 508, + 618 + ], + "lines": [ + { + "bbox": [ + 104, + 573, + 508, + 609 + ], + "spans": [ + { + "bbox": [ + 104, + 573, + 111, + 590 + ], + "score": 1.0, + "content": "d", + "type": "text" + }, + { + "bbox": [ + 111, + 573, + 508, + 609 + ], + "score": 0.34, + "content": "\\begin{array} { r l } & { \\mathfrak { l } ( a _ { t } , s _ { t } , \\epsilon ) = \\operatorname* { m a x } _ { \\mu \\in \\{ \\underline { { \\mu } } , \\vec { \\mu } \\} } ( a _ { t } - \\mu ) ^ { T } \\Sigma ^ { - 1 } ( a _ { t } - \\mu ) , \\underline { { d } } ( a _ { t } , s _ { t } , \\epsilon ) = \\operatorname* { m i n } _ { \\mu \\in [ \\underline { { \\mu } } , \\vec { \\mu } ] } ( a _ { t } - \\mu ) ^ { T } \\Sigma ^ { - 1 } ( a _ { t } - \\mu ) } \\\\ & { \\mathrm { ~ h e n ~ } \\overline { { \\pi } } ( a _ { t } | s _ { t } , \\epsilon ; \\theta ) = \\frac { e ^ { - \\frac { d } { d } / 2 } } { ( ( 2 \\pi ) ^ { k } \\operatorname* { d e t } \\Sigma ) ^ { 0 . 5 } } \\mathrm { ~ a n d ~ } \\underline { { \\pi } } ( a _ { t } | s _ { t } , \\epsilon ; \\theta ) = \\frac { e ^ { - \\overline { { d } } / 2 } } { ( ( 2 \\pi ) ^ { k } \\operatorname* { d e t } \\Sigma ) ^ { 0 . 5 } } \\cdot \\mathrm { ~ W h e r e ~ } k \\mathrm { ~ i s ~ t h e ~ n u m b e r ~ o f ~ } } \\end{array}", + "type": "inline_equation", + "image_path": "1c54fece6a2adb79e5341fd665860f85bf9556312ac966537bd681baa5e03e09.jpg" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 604, + 234, + 619 + ], + "spans": [ + { + "bbox": [ + 106, + 604, + 234, + 619 + ], + "score": 1.0, + "content": "dimensions in the action space.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5 + }, + { + "type": "text", + "bbox": [ + 106, + 622, + 505, + 657 + ], + "lines": [ + { + "bbox": [ + 105, + 622, + 506, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 188, + 636 + ], + "score": 1.0, + "content": "For discrete action,", + "type": "text" + }, + { + "bbox": [ + 188, + 625, + 195, + 633 + ], + "score": 0.76, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 622, + 429, + 636 + ], + "score": 1.0, + "content": "is a categorical distribution over possible actions, where", + "type": "text" + }, + { + "bbox": [ + 429, + 623, + 453, + 635 + ], + "score": 0.92, + "content": "\\overline { { \\pi } } ( a _ { t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 622, + 506, + 636 + ], + "score": 1.0, + "content": "is the upper", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 634, + 505, + 646 + ], + "spans": [ + { + "bbox": [ + 106, + 634, + 221, + 646 + ], + "score": 1.0, + "content": "bound of the policy network", + "type": "text" + }, + { + "bbox": [ + 221, + 636, + 229, + 644 + ], + "score": 0.78, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 229, + 634, + 239, + 646 + ], + "score": 1.0, + "content": "at", + "type": "text" + }, + { + "bbox": [ + 240, + 635, + 249, + 645 + ], + "score": 0.87, + "content": "a _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 634, + 483, + 646 + ], + "score": 1.0, + "content": "-th output. This can be computed from the upper bound of", + "type": "text" + }, + { + "bbox": [ + 483, + 635, + 492, + 645 + ], + "score": 0.85, + "content": "a _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 493, + 634, + 505, + 646 + ], + "score": 1.0, + "content": "-th", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 644, + 437, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 437, + 658 + ], + "score": 1.0, + "content": "logit(output before softmax) and lower bound of other logits by applying softmax.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47 + }, + { + "type": "title", + "bbox": [ + 107, + 668, + 389, + 681 + ], + "lines": [ + { + "bbox": [ + 105, + 668, + 389, + 682 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 389, + 682 + ], + "score": 1.0, + "content": "3.4 New efficient evaluation metric: Greedy Worst-Case Reward", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 49 + }, + { + "type": "text", + "bbox": [ + 107, + 689, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 688, + 505, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 505, + 702 + ], + "score": 1.0, + "content": "The goal of training RL agents robust against input perturbations is to ensure that the agents could still", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 699, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 713 + ], + "score": 1.0, + "content": "perform well under any (bounded) adversarial perturbations. This can be translated into maximizing", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 106, + 711, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 195, + 723 + ], + "score": 1.0, + "content": "the worst-case reward", + "type": "text" + }, + { + "bbox": [ + 195, + 711, + 214, + 722 + ], + "score": 0.91, + "content": "R _ { w c }", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 711, + 506, + 723 + ], + "score": 1.0, + "content": ", which is the reward under worst possible sequence of adversarial attacks.", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 51 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 310, + 752 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 114, + 78, + 284, + 219 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 114, + 78, + 284, + 219 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 114, + 78, + 284, + 219 + ], + "spans": [ + { + "bbox": [ + 114, + 78, + 284, + 219 + ], + "score": 0.952, + "type": "image", + "image_path": "6c9e9d36358ef5d3e304ac88c13e30f6b9509dfe8e774585db0bf8244ffaad53.jpg" + } + ] + } + ], + "index": 4.5, + "virtual_lines": [ + { + "bbox": [ + 114, + 78, + 284, + 92.1 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 114, + 92.1, + 284, + 106.19999999999999 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 114, + 106.19999999999999, + 284, + 120.29999999999998 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 114, + 120.29999999999998, + 284, + 134.39999999999998 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 114, + 134.39999999999998, + 284, + 148.49999999999997 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 114, + 148.49999999999997, + 284, + 162.59999999999997 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 114, + 162.59999999999997, + 284, + 176.69999999999996 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 114, + 176.69999999999996, + 284, + 190.79999999999995 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 114, + 190.79999999999995, + 284, + 204.89999999999995 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 114, + 204.89999999999995, + 284, + 218.99999999999994 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 232, + 307, + 255 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 232, + 307, + 245 + ], + "spans": [ + { + "bbox": [ + 106, + 232, + 202, + 245 + ], + "score": 1.0, + "content": "Figure 2: Visualizing", + "type": "text" + }, + { + "bbox": [ + 202, + 233, + 221, + 244 + ], + "score": 0.9, + "content": "L _ { \\mathrm { a d v } }", + "type": "inline_equation" + }, + { + "bbox": [ + 221, + 232, + 307, + 245 + ], + "score": 1.0, + "content": "for RADIAL-DQN", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 243, + 294, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 294, + 255 + ], + "score": 1.0, + "content": "(Approach #2) in a simple case with 2 actions.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5 + } + ], + "index": 7.5 + }, + { + "type": "title", + "bbox": [ + 321, + 87, + 489, + 98 + ], + "lines": [ + { + "bbox": [ + 320, + 86, + 490, + 100 + ], + "spans": [ + { + "bbox": [ + 320, + 86, + 490, + 100 + ], + "score": 1.0, + "content": "Algorithm 1: Greedy Worst-Case Reward", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "list", + "bbox": [ + 320, + 101, + 491, + 241 + ], + "lines": [ + { + "bbox": [ + 320, + 98, + 349, + 112 + ], + "spans": [ + { + "bbox": [ + 320, + 98, + 348, + 110 + ], + "score": 0.33, + "content": "\\overline { { R = 0 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 348, + 99, + 349, + 112 + ], + "score": 0.0, + "content": "", + "type": "text" + } + ], + "index": 13, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 320, + 111, + 420, + 122 + ], + "spans": [ + { + "bbox": [ + 320, + 111, + 345, + 122 + ], + "score": 1.0, + "content": "while", + "type": "text" + }, + { + "bbox": [ + 345, + 113, + 354, + 122 + ], + "score": 0.81, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 355, + 111, + 420, + 122 + ], + "score": 1.0, + "content": "not terminal do", + "type": "text" + } + ], + "index": 14, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 334, + 120, + 488, + 135 + ], + "spans": [ + { + "bbox": [ + 334, + 120, + 385, + 135 + ], + "score": 1.0, + "content": "1. Calculate", + "type": "text" + }, + { + "bbox": [ + 386, + 122, + 421, + 133 + ], + "score": 0.9, + "content": "\\pi _ { i } ( s _ { t } , \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 421, + 120, + 425, + 135 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 425, + 122, + 469, + 134 + ], + "score": 0.89, + "content": "\\underline { { \\pi } } _ { i } ( s _ { t } , \\epsilon ; \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 469, + 120, + 488, + 135 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 340, + 132, + 453, + 145 + ], + "spans": [ + { + "bbox": [ + 340, + 133, + 385, + 144 + ], + "score": 0.9, + "content": "\\overline { { \\pi } } _ { i } ( s _ { t } , \\epsilon ; \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 132, + 448, + 145 + ], + "score": 1.0, + "content": "for each action", + "type": "text" + }, + { + "bbox": [ + 448, + 134, + 453, + 142 + ], + "score": 0.64, + "content": "i", + "type": "inline_equation" + } + ], + "index": 16, + "is_list_end_line": true + }, + { + "bbox": [ + 335, + 142, + 477, + 155 + ], + "spans": [ + { + "bbox": [ + 335, + 142, + 477, + 155 + ], + "score": 1.0, + "content": "2. Calculate set of possible actions", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 340, + 154, + 449, + 168 + ], + "spans": [ + { + "bbox": [ + 340, + 154, + 449, + 168 + ], + "score": 0.8, + "content": "\\Gamma : = \\{ i | \\overline { { \\pi } } _ { i } \\geq \\operatorname* { m a x } _ { j } ( \\underline { { \\pi } } _ { j } ) \\}", + "type": "inline_equation" + } + ], + "index": 18, + "is_list_end_line": true + }, + { + "bbox": [ + 335, + 164, + 490, + 176 + ], + "spans": [ + { + "bbox": [ + 335, + 164, + 441, + 176 + ], + "score": 1.0, + "content": "3. Take the \"worst\" action", + "type": "text" + }, + { + "bbox": [ + 442, + 167, + 448, + 175 + ], + "score": 0.79, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 164, + 490, + 176 + ], + "score": 1.0, + "content": "out of the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 340, + 176, + 409, + 188 + ], + "spans": [ + { + "bbox": [ + 340, + 176, + 409, + 188 + ], + "score": 1.0, + "content": "possible actions,", + "type": "text" + } + ], + "index": 20, + "is_list_end_line": true + }, + { + "bbox": [ + 340, + 186, + 485, + 201 + ], + "spans": [ + { + "bbox": [ + 340, + 187, + 444, + 200 + ], + "score": 0.88, + "content": "k = \\mathrm { a r g m i n } _ { i \\in \\Gamma } ( \\pi _ { i } ( s _ { t } , \\theta ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 186, + 485, + 201 + ], + "score": 1.0, + "content": ". Observe", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 340, + 198, + 487, + 210 + ], + "spans": [ + { + "bbox": [ + 340, + 200, + 350, + 209 + ], + "score": 0.8, + "content": "r _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 350, + 198, + 368, + 210 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 368, + 200, + 387, + 210 + ], + "score": 0.87, + "content": "s _ { t + 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 198, + 435, + 210 + ], + "score": 1.0, + "content": "and update", + "type": "text" + }, + { + "bbox": [ + 435, + 199, + 487, + 209 + ], + "score": 0.9, + "content": "R \\gets R + r _ { t }", + "type": "inline_equation" + } + ], + "index": 22 + }, + { + "bbox": [ + 334, + 208, + 385, + 221 + ], + "spans": [ + { + "bbox": [ + 334, + 208, + 345, + 221 + ], + "score": 1.0, + "content": "4.", + "type": "text" + }, + { + "bbox": [ + 345, + 210, + 385, + 219 + ], + "score": 0.72, + "content": "t = t + 1", + "type": "inline_equation" + } + ], + "index": 23, + "is_list_end_line": true + }, + { + "bbox": [ + 319, + 218, + 340, + 230 + ], + "spans": [ + { + "bbox": [ + 319, + 218, + 340, + 230 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 24, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 319, + 229, + 360, + 240 + ], + "spans": [ + { + "bbox": [ + 319, + 229, + 350, + 240 + ], + "score": 1.0, + "content": "return", + "type": "text" + }, + { + "bbox": [ + 350, + 230, + 360, + 240 + ], + "score": 0.61, + "content": "R", + "type": "inline_equation" + } + ], + "index": 25, + "is_list_start_line": true, + "is_list_end_line": true + } + ], + "index": 19, + "bbox_fs": [ + 319, + 98, + 490, + 240 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 275, + 505, + 299 + ], + "lines": [ + { + "bbox": [ + 105, + 273, + 503, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 126, + 289 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 127, + 275, + 285, + 287 + ], + "score": 0.9, + "content": "\\pi _ { \\operatorname { d i f f } } ( s , y ) = \\operatorname* { m a x } ( 0 , \\pi ( s , a ) - \\pi ( s , y ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 273, + 304, + 289 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 304, + 275, + 503, + 288 + ], + "score": 0.82, + "content": "O v l ( s , y , \\epsilon ) = \\operatorname* { m a x } ( 0 , \\overline { { z } } ( s , y , \\epsilon ) - \\underline { { z } } ( s , a , \\epsilon ) + \\eta )", + "type": "inline_equation" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 284, + 388, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 135, + 300 + ], + "score": 1.0, + "content": "Where", + "type": "text" + }, + { + "bbox": [ + 135, + 287, + 212, + 299 + ], + "score": 0.9, + "content": "\\eta = 0 . 5 \\cdot z _ { \\mathrm { d i f f } } ( s , y )", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 284, + 230, + 300 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 230, + 287, + 383, + 299 + ], + "score": 0.9, + "content": "z _ { \\mathrm { d i f f } } ( s , y ) = \\operatorname* { m a x } ( 0 , z ( s , a ) - z ( s , y ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 284, + 388, + 300 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 273, + 503, + 300 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 310, + 194, + 322 + ], + "lines": [ + { + "bbox": [ + 105, + 309, + 194, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 194, + 325 + ], + "score": 1.0, + "content": "3.3 RADIAL-PPO", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 106, + 331, + 505, + 386 + ], + "lines": [ + { + "bbox": [ + 105, + 330, + 507, + 344 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 344, + 344 + ], + "score": 1.0, + "content": "For RADIAL-PPO, we use Approach #1 as Approach", + "type": "text" + }, + { + "bbox": [ + 345, + 331, + 357, + 341 + ], + "score": 0.51, + "content": "\\# 2", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 330, + 507, + 344 + ], + "score": 1.0, + "content": "does not work for continuous ac-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 341, + 505, + 355 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 505, + 355 + ], + "score": 1.0, + "content": "tions(discussion in Appendix C). In RADIAL-PPO, we only calculate bounds over current policy", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 353, + 505, + 366 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 505, + 366 + ], + "score": 1.0, + "content": "output, because the experiences are generated by sampling from unperturbed old policy, and value", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 362, + 506, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 506, + 377 + ], + "score": 1.0, + "content": "function/advantage are only used during training. The intuition for Approach #1 is to derive an upper", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 374, + 318, + 387 + ], + "spans": [ + { + "bbox": [ + 106, + 374, + 318, + 387 + ], + "score": 1.0, + "content": "bound of the RHS of Eqn. 3 which will always hold.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31, + "bbox_fs": [ + 105, + 330, + 507, + 387 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 390, + 505, + 435 + ], + "lines": [ + { + "bbox": [ + 106, + 389, + 506, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 317, + 403 + ], + "score": 0.87, + "content": "\\forall s _ { t } \\in S , \\forall | | \\delta | | _ { p } \\leq \\epsilon \\ ; \\mathcal { L } ( \\theta , s _ { t } + \\delta ) \\leq \\mathcal { L } _ { \\mathrm { a d v } } ( \\theta , s _ { t } , \\epsilon )", + "type": "inline_equation" + }, + { + "bbox": [ + 318, + 389, + 506, + 404 + ], + "score": 1.0, + "content": ". Minimizing this upper bound will then also", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "score": 1.0, + "content": "decrease the loss under perturbation. In practice optimizing this loss function results in increasing the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 412, + 507, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 325, + 426 + ], + "score": 1.0, + "content": "lower bound of the probability of taking good actions", + "type": "text" + }, + { + "bbox": [ + 326, + 413, + 358, + 424 + ], + "score": 0.88, + "content": "( A _ { t } \\geq 0 )", + "type": "inline_equation" + }, + { + "bbox": [ + 358, + 412, + 507, + 426 + ], + "score": 1.0, + "content": "), and decreasing the upper bound of", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 424, + 284, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 424, + 246, + 435 + ], + "score": 1.0, + "content": "the probability to take bad actions", + "type": "text" + }, + { + "bbox": [ + 246, + 424, + 279, + 435 + ], + "score": 0.88, + "content": "( A _ { t } < 0 )", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 424, + 284, + 435 + ], + "score": 1.0, + "content": ").", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 389, + 507, + 435 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 439, + 319, + 452 + ], + "lines": [ + { + "bbox": [ + 105, + 437, + 320, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 232, + 454 + ], + "score": 1.0, + "content": "The mathematical definition of", + "type": "text" + }, + { + "bbox": [ + 232, + 441, + 250, + 451 + ], + "score": 0.91, + "content": "{ \\mathcal { L } } _ { \\mathrm { a d v } }", + "type": "inline_equation" + }, + { + "bbox": [ + 251, + 437, + 320, + 454 + ], + "score": 1.0, + "content": "is the following:", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 437, + 320, + 454 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 129, + 456, + 480, + 483 + ], + "lines": [ + { + "bbox": [ + 129, + 456, + 480, + 483 + ], + "spans": [ + { + "bbox": [ + 129, + 456, + 480, + 483 + ], + "score": 0.92, + "content": "\\mathcal { L } _ { \\mathrm { a d v } } ( \\theta , \\epsilon ) = \\mathbb { E } _ { ( s _ { t } , a _ { t } , r _ { t } ) } \\left[ - \\operatorname* { m i n } ( \\frac { \\hat { \\pi } ( a _ { t } | s _ { t } , \\epsilon ; \\theta ) } { \\pi ( a _ { t } | s _ { t } ; \\theta _ { \\mathrm { o l d } } ) } A _ { t } , \\mathrm { c l i p } ( \\frac { \\hat { \\pi } ( a _ { t } | s _ { t } , \\epsilon ; \\theta ) } { \\pi ( a _ { t } | s _ { t } ; \\theta _ { \\mathrm { o l d } } ) } , 1 - \\eta , 1 + \\eta ) A _ { t } ) \\right] .", + "type": "interline_equation", + "image_path": "a65430ac47d8d19456c9232e2055935426825b5e86ec57fb3f48aeae22d72438.jpg" + } + ] + } + ], + "index": 39, + "virtual_lines": [ + { + "bbox": [ + 129, + 456, + 480, + 483 + ], + "spans": [], + "index": 39 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 492, + 250, + 504 + ], + "lines": [ + { + "bbox": [ + 106, + 492, + 251, + 506 + ], + "spans": [ + { + "bbox": [ + 106, + 492, + 251, + 506 + ], + "score": 1.0, + "content": "The worst-case policy is defined as:", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40, + "bbox_fs": [ + 106, + 492, + 251, + 506 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 216, + 509, + 394, + 537 + ], + "lines": [ + { + "bbox": [ + 216, + 509, + 394, + 537 + ], + "spans": [ + { + "bbox": [ + 216, + 509, + 394, + 537 + ], + "score": 0.93, + "content": "\\hat { \\pi } ( a _ { t } | s _ { t } , \\epsilon ; \\theta ) = \\left\\{ \\frac { \\pi ( a _ { t } | s _ { t } , \\epsilon ; \\theta ) , \\ \\mathrm { i f } \\ A _ { t } \\geq 0 } { \\pi ( a _ { t } | s _ { t } , \\epsilon ; \\theta ) , \\ \\mathrm { o t h e r w i s e } } \\right.", + "type": "interline_equation", + "image_path": "0c60b2a8549c800f95ec7f3bb3600df305f8ffa629996b2c38a6ed507962e41c.jpg" + } + ] + } + ], + "index": 41, + "virtual_lines": [ + { + "bbox": [ + 216, + 509, + 394, + 537 + ], + "spans": [], + "index": 41 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 547, + 505, + 570 + ], + "lines": [ + { + "bbox": [ + 106, + 547, + 506, + 560 + ], + "spans": [ + { + "bbox": [ + 106, + 547, + 429, + 560 + ], + "score": 1.0, + "content": "For our continuous control experiments, the output of our policy are the parameters", + "type": "text" + }, + { + "bbox": [ + 429, + 548, + 448, + 559 + ], + "score": 0.9, + "content": "\\mu , \\Sigma", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 547, + 506, + 560 + ], + "score": 1.0, + "content": "of a Gaussian,", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 558, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 351, + 570 + ], + "score": 1.0, + "content": "with covariance being diagonal and independent of input state", + "type": "text" + }, + { + "bbox": [ + 351, + 560, + 357, + 568 + ], + "score": 0.67, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 558, + 496, + 570 + ], + "score": 1.0, + "content": ". We can define bounds on distance", + "type": "text" + }, + { + "bbox": [ + 496, + 559, + 502, + 568 + ], + "score": 0.82, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 503, + 558, + 506, + 570 + ], + "score": 1.0, + "content": ":", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5, + "bbox_fs": [ + 105, + 547, + 506, + 570 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 573, + 508, + 618 + ], + "lines": [ + { + "bbox": [ + 104, + 573, + 508, + 609 + ], + "spans": [ + { + "bbox": [ + 104, + 573, + 111, + 590 + ], + "score": 1.0, + "content": "d", + "type": "text" + }, + { + "bbox": [ + 111, + 573, + 508, + 609 + ], + "score": 0.34, + "content": "\\begin{array} { r l } & { \\mathfrak { l } ( a _ { t } , s _ { t } , \\epsilon ) = \\operatorname* { m a x } _ { \\mu \\in \\{ \\underline { { \\mu } } , \\vec { \\mu } \\} } ( a _ { t } - \\mu ) ^ { T } \\Sigma ^ { - 1 } ( a _ { t } - \\mu ) , \\underline { { d } } ( a _ { t } , s _ { t } , \\epsilon ) = \\operatorname* { m i n } _ { \\mu \\in [ \\underline { { \\mu } } , \\vec { \\mu } ] } ( a _ { t } - \\mu ) ^ { T } \\Sigma ^ { - 1 } ( a _ { t } - \\mu ) } \\\\ & { \\mathrm { ~ h e n ~ } \\overline { { \\pi } } ( a _ { t } | s _ { t } , \\epsilon ; \\theta ) = \\frac { e ^ { - \\frac { d } { d } / 2 } } { ( ( 2 \\pi ) ^ { k } \\operatorname* { d e t } \\Sigma ) ^ { 0 . 5 } } \\mathrm { ~ a n d ~ } \\underline { { \\pi } } ( a _ { t } | s _ { t } , \\epsilon ; \\theta ) = \\frac { e ^ { - \\overline { { d } } / 2 } } { ( ( 2 \\pi ) ^ { k } \\operatorname* { d e t } \\Sigma ) ^ { 0 . 5 } } \\cdot \\mathrm { ~ W h e r e ~ } k \\mathrm { ~ i s ~ t h e ~ n u m b e r ~ o f ~ } } \\end{array}", + "type": "inline_equation", + "image_path": "1c54fece6a2adb79e5341fd665860f85bf9556312ac966537bd681baa5e03e09.jpg" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 604, + 234, + 619 + ], + "spans": [ + { + "bbox": [ + 106, + 604, + 234, + 619 + ], + "score": 1.0, + "content": "dimensions in the action space.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5, + "bbox_fs": [ + 104, + 573, + 508, + 619 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 622, + 505, + 657 + ], + "lines": [ + { + "bbox": [ + 105, + 622, + 506, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 188, + 636 + ], + "score": 1.0, + "content": "For discrete action,", + "type": "text" + }, + { + "bbox": [ + 188, + 625, + 195, + 633 + ], + "score": 0.76, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 622, + 429, + 636 + ], + "score": 1.0, + "content": "is a categorical distribution over possible actions, where", + "type": "text" + }, + { + "bbox": [ + 429, + 623, + 453, + 635 + ], + "score": 0.92, + "content": "\\overline { { \\pi } } ( a _ { t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 622, + 506, + 636 + ], + "score": 1.0, + "content": "is the upper", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 634, + 505, + 646 + ], + "spans": [ + { + "bbox": [ + 106, + 634, + 221, + 646 + ], + "score": 1.0, + "content": "bound of the policy network", + "type": "text" + }, + { + "bbox": [ + 221, + 636, + 229, + 644 + ], + "score": 0.78, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 229, + 634, + 239, + 646 + ], + "score": 1.0, + "content": "at", + "type": "text" + }, + { + "bbox": [ + 240, + 635, + 249, + 645 + ], + "score": 0.87, + "content": "a _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 634, + 483, + 646 + ], + "score": 1.0, + "content": "-th output. This can be computed from the upper bound of", + "type": "text" + }, + { + "bbox": [ + 483, + 635, + 492, + 645 + ], + "score": 0.85, + "content": "a _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 493, + 634, + 505, + 646 + ], + "score": 1.0, + "content": "-th", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 644, + 437, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 437, + 658 + ], + "score": 1.0, + "content": "logit(output before softmax) and lower bound of other logits by applying softmax.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47, + "bbox_fs": [ + 105, + 622, + 506, + 658 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 668, + 389, + 681 + ], + "lines": [ + { + "bbox": [ + 105, + 668, + 389, + 682 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 389, + 682 + ], + "score": 1.0, + "content": "3.4 New efficient evaluation metric: Greedy Worst-Case Reward", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 49 + }, + { + "type": "text", + "bbox": [ + 107, + 689, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 688, + 505, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 505, + 702 + ], + "score": 1.0, + "content": "The goal of training RL agents robust against input perturbations is to ensure that the agents could still", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 699, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 713 + ], + "score": 1.0, + "content": "perform well under any (bounded) adversarial perturbations. This can be translated into maximizing", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 106, + 711, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 195, + 723 + ], + "score": 1.0, + "content": "the worst-case reward", + "type": "text" + }, + { + "bbox": [ + 195, + 711, + 214, + 722 + ], + "score": 0.91, + "content": "R _ { w c }", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 711, + 506, + 723 + ], + "score": 1.0, + "content": ", which is the reward under worst possible sequence of adversarial attacks.", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 51, + "bbox_fs": [ + 105, + 688, + 506, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 72, + 505, + 194 + ], + "lines": [ + { + "bbox": [ + 105, + 71, + 505, + 87 + ], + "spans": [ + { + "bbox": [ + 105, + 71, + 150, + 87 + ], + "score": 1.0, + "content": "We define", + "type": "text" + }, + { + "bbox": [ + 151, + 73, + 169, + 84 + ], + "score": 0.9, + "content": "R _ { w c }", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 71, + 220, + 87 + ], + "score": 1.0, + "content": "as follows:", + "type": "text" + }, + { + "bbox": [ + 221, + 73, + 342, + 85 + ], + "score": 0.89, + "content": "\\begin{array} { r } { R _ { w c } = \\operatorname* { m i n } _ { | | \\delta _ { t } | | _ { p } \\leq \\epsilon } \\mathbb { E } _ { \\tau } [ R ( \\tau ) ] } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 71, + 407, + 87 + ], + "score": 1.0, + "content": "with trajectory", + "type": "text" + }, + { + "bbox": [ + 407, + 73, + 505, + 85 + ], + "score": 0.9, + "content": "\\tau = ( s _ { 0 } , a _ { 0 } , . . . , s _ { T } , a _ { T } )", + "type": "inline_equation" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 84, + 505, + 99 + ], + "spans": [ + { + "bbox": [ + 105, + 84, + 132, + 99 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 87, + 168, + 96 + ], + "score": 0.88, + "content": "a _ { t } , s _ { t } , r _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 84, + 232, + 99 + ], + "score": 1.0, + "content": "are drawn from", + "type": "text" + }, + { + "bbox": [ + 232, + 86, + 339, + 97 + ], + "score": 0.6, + "content": "\\pi ( s _ { t } + \\delta _ { t } ) , { \\mathcal { P } } ( s _ { t - 1 } , a _ { t - 1 } ) ,", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 85, + 401, + 97 + ], + "score": 0.88, + "content": "\\mathscr { R } ( s _ { t - 1 } , a _ { t - 1 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 84, + 471, + 99 + ], + "score": 1.0, + "content": "respectively, and", + "type": "text" + }, + { + "bbox": [ + 471, + 85, + 505, + 97 + ], + "score": 0.9, + "content": "R ( \\tau ) =", + "type": "inline_equation" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 95, + 506, + 109 + ], + "spans": [ + { + "bbox": [ + 106, + 96, + 131, + 108 + ], + "score": 0.9, + "content": "\\textstyle \\sum _ { t } r _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 95, + 333, + 109 + ], + "score": 1.0, + "content": ". One idea is to evaluate every possible trajectory", + "type": "text" + }, + { + "bbox": [ + 333, + 98, + 340, + 106 + ], + "score": 0.76, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 95, + 506, + 109 + ], + "score": 1.0, + "content": "to find which one produces the minimal", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 106, + 506, + 120 + ], + "spans": [ + { + "bbox": [ + 105, + 106, + 177, + 120 + ], + "score": 1.0, + "content": "reward. However", + "type": "text" + }, + { + "bbox": [ + 177, + 107, + 196, + 118 + ], + "score": 0.91, + "content": "R _ { w c }", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 106, + 477, + 120 + ], + "score": 1.0, + "content": "is practically impossible to evaluate, as finding the worst perturbations", + "type": "text" + }, + { + "bbox": [ + 477, + 107, + 486, + 118 + ], + "score": 0.87, + "content": "\\delta _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 106, + 506, + 120 + ], + "score": 1.0, + "content": "of a", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 117, + 506, + 131 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 194, + 131 + ], + "score": 1.0, + "content": "set of possible actions", + "type": "text" + }, + { + "bbox": [ + 194, + 119, + 204, + 129 + ], + "score": 0.85, + "content": "a _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 117, + 259, + 131 + ], + "score": 1.0, + "content": "for each state", + "type": "text" + }, + { + "bbox": [ + 259, + 119, + 269, + 129 + ], + "score": 0.85, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 117, + 506, + 131 + ], + "score": 1.0, + "content": "is NP-hard, and the amount of trajectories to evaluate grows", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 129, + 506, + 141 + ], + "spans": [ + { + "bbox": [ + 105, + 129, + 286, + 141 + ], + "score": 1.0, + "content": "exponentially with respect to trajectory length", + "type": "text" + }, + { + "bbox": [ + 286, + 129, + 295, + 138 + ], + "score": 0.79, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 129, + 506, + 141 + ], + "score": 1.0, + "content": ", which is hard to compute. One possible way to avoid", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 139, + 506, + 152 + ], + "spans": [ + { + "bbox": [ + 105, + 139, + 506, + 152 + ], + "score": 1.0, + "content": "finding worst-case perturbations directly is to use certified output bounds [12, 13, 11, 31, 32, 33],", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 151, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 106, + 151, + 505, + 162 + ], + "score": 1.0, + "content": "which produces a superset of all possible actions under worst-case perturbations and hence the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 161, + 504, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 161, + 338, + 174 + ], + "score": 1.0, + "content": "resulting total accumulative reward is a lower bound of", + "type": "text" + }, + { + "bbox": [ + 339, + 162, + 357, + 172 + ], + "score": 0.9, + "content": "R _ { w c }", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 161, + 504, + 174 + ], + "score": 1.0, + "content": ". We name this reward as Absolute", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 172, + 505, + 185 + ], + "spans": [ + { + "bbox": [ + 105, + 172, + 377, + 185 + ], + "score": 1.0, + "content": "Worst-Case Reward (AWC). Note that AWC is a lower bound of", + "type": "text" + }, + { + "bbox": [ + 377, + 172, + 396, + 183 + ], + "score": 0.91, + "content": "R _ { w c }", + "type": "inline_equation" + }, + { + "bbox": [ + 396, + 172, + 505, + 185 + ], + "score": 1.0, + "content": "when both the policy and", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 184, + 230, + 194 + ], + "spans": [ + { + "bbox": [ + 106, + 184, + 230, + 194 + ], + "score": 1.0, + "content": "environment are deterministic.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 107, + 199, + 505, + 298 + ], + "lines": [ + { + "bbox": [ + 105, + 199, + 506, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 506, + 212 + ], + "score": 1.0, + "content": "However, AWC still requires evaluating an exponential amount of possible action sequences, which is", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 210, + 506, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 506, + 223 + ], + "score": 1.0, + "content": "computationally expensive. To overcome this limitation, we propose an alternative evaluation method", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 221, + 506, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 468, + 234 + ], + "score": 1.0, + "content": "called Greedy Worst-Case Reward (GWC) in Algorithm 1, which approximates the desired", + "type": "text" + }, + { + "bbox": [ + 468, + 222, + 487, + 232 + ], + "score": 0.9, + "content": "R _ { w c }", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 221, + 506, + 234 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 232, + 506, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 397, + 245 + ], + "score": 1.0, + "content": "can be computed efficiently with a linear complexity of total timesteps", + "type": "text" + }, + { + "bbox": [ + 397, + 233, + 406, + 242 + ], + "score": 0.69, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 232, + 506, + 245 + ], + "score": 1.0, + "content": ". The idea of GWC is to", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 241, + 504, + 257 + ], + "spans": [ + { + "bbox": [ + 104, + 241, + 485, + 257 + ], + "score": 1.0, + "content": "avoid evaluating exponential numbers of trajectories and use a simple heuristic to approximate", + "type": "text" + }, + { + "bbox": [ + 485, + 243, + 504, + 254 + ], + "score": 0.89, + "content": "R _ { w c }", + "type": "inline_equation" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 253, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 505, + 266 + ], + "score": 1.0, + "content": "by choosing the action with lowest Q-value (or the probability of action taken for A3C) greedily at", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 265, + 506, + 278 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 506, + 278 + ], + "score": 1.0, + "content": "each state. We show in Fig 4 (in Appendix E) that GWC is often close to AWC while being much", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 276, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 505, + 289 + ], + "score": 1.0, + "content": "faster to evaluate (linear complexity of total time steps). Discussion about metrics used in baseline", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 286, + 470, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 470, + 299 + ], + "score": 1.0, + "content": "works [17, 18] and full description of the algorithm for computing AWC is in Appendix D.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 15 + }, + { + "type": "title", + "bbox": [ + 108, + 313, + 233, + 327 + ], + "lines": [ + { + "bbox": [ + 104, + 312, + 234, + 330 + ], + "spans": [ + { + "bbox": [ + 104, + 312, + 234, + 330 + ], + "score": 1.0, + "content": "4 Experimental results", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 338, + 505, + 426 + ], + "lines": [ + { + "bbox": [ + 105, + 339, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 505, + 351 + ], + "score": 1.0, + "content": "Environments and setup To have a fair comparison with baseline works [17, 18], we experiment on", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 350, + 506, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 350, + 506, + 362 + ], + "score": 1.0, + "content": "the same Atari-2600 environment [35] and same 4 games used in [17, 18]. Different from [17, 18],", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 361, + 506, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 506, + 373 + ], + "score": 1.0, + "content": "we further evaluate our algorithm on a more challenging ProcGen [36] benchmark, which allows us", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 371, + 506, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 506, + 383 + ], + "score": 1.0, + "content": "to test generalization abilities of the agent. Note that both Atari-games and ProcGen [36] benchmark", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 383, + 505, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 505, + 395 + ], + "score": 1.0, + "content": "have high dimensional pixel inputs and discrete action spaces. To compare our RL agents with", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 393, + 505, + 406 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 505, + 406 + ], + "score": 1.0, + "content": "continuous actions with [17], we use the MuJoCo environment which simulates robotic control", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "score": 1.0, + "content": "and has relatively low-dimensional inputs and a continuous action space. Full training details and", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 416, + 322, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 322, + 428 + ], + "score": 1.0, + "content": "hyperparameter settings are available in Appendix H.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 107, + 431, + 505, + 497 + ], + "lines": [ + { + "bbox": [ + 105, + 431, + 506, + 444 + ], + "spans": [ + { + "bbox": [ + 105, + 431, + 506, + 444 + ], + "score": 1.0, + "content": "Evaluation. We evaluate the performance of our agents with a total of 3 metrics: (a) total reward under", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 441, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 141, + 455 + ], + "score": 1.0, + "content": "10-steps", + "type": "text" + }, + { + "bbox": [ + 142, + 442, + 154, + 453 + ], + "score": 0.87, + "content": "l _ { \\infty }", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 441, + 505, + 455 + ], + "score": 1.0, + "content": "-PGD untargeted attack applied on every frame, (b) GWC and (c) Action Certification", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "score": 1.0, + "content": "Rate (ACR)[17]. For Atari games the result of Approach #2 for RADIAL-agents are in Table 1, and", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 464, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 505, + 477 + ], + "score": 1.0, + "content": "the results of Approach #1 are in Appendix I. Note that A3C and PPO take actions stochastically", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 474, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 506, + 488 + ], + "score": 1.0, + "content": "during training but we set them to deterministically choose the action that has the highest probability", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 486, + 181, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 181, + 500 + ], + "score": 1.0, + "content": "during evaluation.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 31.5 + }, + { + "type": "title", + "bbox": [ + 107, + 510, + 183, + 522 + ], + "lines": [ + { + "bbox": [ + 105, + 509, + 185, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 185, + 523 + ], + "score": 1.0, + "content": "4.1 Atari results", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 106, + 530, + 506, + 673 + ], + "lines": [ + { + "bbox": [ + 105, + 530, + 506, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 506, + 543 + ], + "score": 1.0, + "content": "Table 1 shows that RADIAL-DQN outperforms or matches all the baselines on all four games", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 542, + 506, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 137, + 554 + ], + "score": 1.0, + "content": "against", + "type": "text" + }, + { + "bbox": [ + 138, + 542, + 182, + 554 + ], + "score": 0.91, + "content": "\\epsilon = 1 / 2 5 5", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 542, + 506, + 554 + ], + "score": 1.0, + "content": "PGD-attacks with the same evaluation method in [17]. The result suggests that", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 551, + 506, + 567 + ], + "spans": [ + { + "bbox": [ + 104, + 551, + 279, + 567 + ], + "score": 1.0, + "content": "RADIAL can train a robust policy against", + "type": "text" + }, + { + "bbox": [ + 279, + 552, + 323, + 564 + ], + "score": 0.92, + "content": "\\epsilon = 1 / 2 5 5", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 551, + 506, + 567 + ], + "score": 1.0, + "content": "adversarial perturbations without sacrificing", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 564, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 106, + 564, + 505, + 576 + ], + "score": 1.0, + "content": "nominal performance. In fact, our robust RADIAL agents consistently outperform the baselines on", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 574, + 506, + 587 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 506, + 587 + ], + "score": 1.0, + "content": "all the evaluation metrics, with significant margin in RoadRunner. In addition to better rewards, our", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 585, + 506, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 217, + 598 + ], + "score": 1.0, + "content": "RADIAL-DQN is roughly", + "type": "text" + }, + { + "bbox": [ + 217, + 586, + 231, + 596 + ], + "score": 0.87, + "content": "6 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 232, + 585, + 506, + 598 + ], + "score": 1.0, + "content": "faster to train than [17]. Experimentally if we include the standard", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 596, + 507, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 507, + 609 + ], + "score": 1.0, + "content": "training process, our total run time is only 17 hours compared to SA-DQN’s 35 hours on our hardware.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 607, + 506, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 506, + 620 + ], + "score": 1.0, + "content": "RADIAL-A3C also achieves high rewards under adversarial attacks and beats the baselines on 2/4", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 104, + 616, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 104, + 616, + 506, + 632 + ], + "score": 1.0, + "content": "tasks despite the games likely being chosen by previous work because they are easy for Q-learning", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 104, + 628, + 506, + 642 + ], + "spans": [ + { + "bbox": [ + 104, + 628, + 506, + 642 + ], + "score": 1.0, + "content": "agents. As shown in Table 1 (A3C is excluded because it did not learn Freeway), RADIAL-A3C", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 639, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 505, + 653 + ], + "score": 1.0, + "content": "reaches slightly lower nominal rewards than RADIAL-DQN but shows more robust performance", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 104, + 650, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 104, + 650, + 397, + 664 + ], + "score": 1.0, + "content": "against large perturbations, even outperforming RADIAL-DQN against", + "type": "text" + }, + { + "bbox": [ + 397, + 651, + 438, + 661 + ], + "score": 0.87, + "content": "\\epsilon = 5 / 2 5 5", + "type": "inline_equation" + }, + { + "bbox": [ + 439, + 650, + 506, + 664 + ], + "score": 1.0, + "content": "PGD attacks on", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 662, + 465, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 662, + 465, + 675 + ], + "score": 1.0, + "content": "RoadRunner. This shows RADIAL works well for very different types of RL algorithms.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 108, + 678, + 504, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 678, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 106, + 678, + 506, + 691 + ], + "score": 1.0, + "content": "One interesting finding is that our A3C baseline actually performed well against small PGD-attacks", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 689, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 432, + 702 + ], + "score": 1.0, + "content": "even without robust training (the standard DQN models all perform terribly at", + "type": "text" + }, + { + "bbox": [ + 432, + 689, + 478, + 700 + ], + "score": 0.9, + "content": "\\epsilon = 1 / 2 5 5", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 689, + 506, + 702 + ], + "score": 1.0, + "content": "while", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 699, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 713 + ], + "score": 1.0, + "content": "A3C has comparable or even better performance than the robust trained SA-DQN or RS-DQN.) We", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "believe this is due to two main factors: (a) the network architecture is slightly different from DQN", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 50.5 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 303, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 309, + 753 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 309, + 753 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 72, + 505, + 194 + ], + "lines": [ + { + "bbox": [ + 105, + 71, + 505, + 87 + ], + "spans": [ + { + "bbox": [ + 105, + 71, + 150, + 87 + ], + "score": 1.0, + "content": "We define", + "type": "text" + }, + { + "bbox": [ + 151, + 73, + 169, + 84 + ], + "score": 0.9, + "content": "R _ { w c }", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 71, + 220, + 87 + ], + "score": 1.0, + "content": "as follows:", + "type": "text" + }, + { + "bbox": [ + 221, + 73, + 342, + 85 + ], + "score": 0.89, + "content": "\\begin{array} { r } { R _ { w c } = \\operatorname* { m i n } _ { | | \\delta _ { t } | | _ { p } \\leq \\epsilon } \\mathbb { E } _ { \\tau } [ R ( \\tau ) ] } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 71, + 407, + 87 + ], + "score": 1.0, + "content": "with trajectory", + "type": "text" + }, + { + "bbox": [ + 407, + 73, + 505, + 85 + ], + "score": 0.9, + "content": "\\tau = ( s _ { 0 } , a _ { 0 } , . . . , s _ { T } , a _ { T } )", + "type": "inline_equation" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 84, + 505, + 99 + ], + "spans": [ + { + "bbox": [ + 105, + 84, + 132, + 99 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 87, + 168, + 96 + ], + "score": 0.88, + "content": "a _ { t } , s _ { t } , r _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 84, + 232, + 99 + ], + "score": 1.0, + "content": "are drawn from", + "type": "text" + }, + { + "bbox": [ + 232, + 86, + 339, + 97 + ], + "score": 0.6, + "content": "\\pi ( s _ { t } + \\delta _ { t } ) , { \\mathcal { P } } ( s _ { t - 1 } , a _ { t - 1 } ) ,", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 85, + 401, + 97 + ], + "score": 0.88, + "content": "\\mathscr { R } ( s _ { t - 1 } , a _ { t - 1 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 84, + 471, + 99 + ], + "score": 1.0, + "content": "respectively, and", + "type": "text" + }, + { + "bbox": [ + 471, + 85, + 505, + 97 + ], + "score": 0.9, + "content": "R ( \\tau ) =", + "type": "inline_equation" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 95, + 506, + 109 + ], + "spans": [ + { + "bbox": [ + 106, + 96, + 131, + 108 + ], + "score": 0.9, + "content": "\\textstyle \\sum _ { t } r _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 95, + 333, + 109 + ], + "score": 1.0, + "content": ". One idea is to evaluate every possible trajectory", + "type": "text" + }, + { + "bbox": [ + 333, + 98, + 340, + 106 + ], + "score": 0.76, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 95, + 506, + 109 + ], + "score": 1.0, + "content": "to find which one produces the minimal", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 106, + 506, + 120 + ], + "spans": [ + { + "bbox": [ + 105, + 106, + 177, + 120 + ], + "score": 1.0, + "content": "reward. However", + "type": "text" + }, + { + "bbox": [ + 177, + 107, + 196, + 118 + ], + "score": 0.91, + "content": "R _ { w c }", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 106, + 477, + 120 + ], + "score": 1.0, + "content": "is practically impossible to evaluate, as finding the worst perturbations", + "type": "text" + }, + { + "bbox": [ + 477, + 107, + 486, + 118 + ], + "score": 0.87, + "content": "\\delta _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 106, + 506, + 120 + ], + "score": 1.0, + "content": "of a", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 117, + 506, + 131 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 194, + 131 + ], + "score": 1.0, + "content": "set of possible actions", + "type": "text" + }, + { + "bbox": [ + 194, + 119, + 204, + 129 + ], + "score": 0.85, + "content": "a _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 117, + 259, + 131 + ], + "score": 1.0, + "content": "for each state", + "type": "text" + }, + { + "bbox": [ + 259, + 119, + 269, + 129 + ], + "score": 0.85, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 117, + 506, + 131 + ], + "score": 1.0, + "content": "is NP-hard, and the amount of trajectories to evaluate grows", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 129, + 506, + 141 + ], + "spans": [ + { + "bbox": [ + 105, + 129, + 286, + 141 + ], + "score": 1.0, + "content": "exponentially with respect to trajectory length", + "type": "text" + }, + { + "bbox": [ + 286, + 129, + 295, + 138 + ], + "score": 0.79, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 129, + 506, + 141 + ], + "score": 1.0, + "content": ", which is hard to compute. One possible way to avoid", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 139, + 506, + 152 + ], + "spans": [ + { + "bbox": [ + 105, + 139, + 506, + 152 + ], + "score": 1.0, + "content": "finding worst-case perturbations directly is to use certified output bounds [12, 13, 11, 31, 32, 33],", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 151, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 106, + 151, + 505, + 162 + ], + "score": 1.0, + "content": "which produces a superset of all possible actions under worst-case perturbations and hence the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 161, + 504, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 161, + 338, + 174 + ], + "score": 1.0, + "content": "resulting total accumulative reward is a lower bound of", + "type": "text" + }, + { + "bbox": [ + 339, + 162, + 357, + 172 + ], + "score": 0.9, + "content": "R _ { w c }", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 161, + 504, + 174 + ], + "score": 1.0, + "content": ". We name this reward as Absolute", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 172, + 505, + 185 + ], + "spans": [ + { + "bbox": [ + 105, + 172, + 377, + 185 + ], + "score": 1.0, + "content": "Worst-Case Reward (AWC). Note that AWC is a lower bound of", + "type": "text" + }, + { + "bbox": [ + 377, + 172, + 396, + 183 + ], + "score": 0.91, + "content": "R _ { w c }", + "type": "inline_equation" + }, + { + "bbox": [ + 396, + 172, + 505, + 185 + ], + "score": 1.0, + "content": "when both the policy and", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 184, + 230, + 194 + ], + "spans": [ + { + "bbox": [ + 106, + 184, + 230, + 194 + ], + "score": 1.0, + "content": "environment are deterministic.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 5, + "bbox_fs": [ + 105, + 71, + 506, + 194 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 199, + 505, + 298 + ], + "lines": [ + { + "bbox": [ + 105, + 199, + 506, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 506, + 212 + ], + "score": 1.0, + "content": "However, AWC still requires evaluating an exponential amount of possible action sequences, which is", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 210, + 506, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 506, + 223 + ], + "score": 1.0, + "content": "computationally expensive. To overcome this limitation, we propose an alternative evaluation method", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 221, + 506, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 468, + 234 + ], + "score": 1.0, + "content": "called Greedy Worst-Case Reward (GWC) in Algorithm 1, which approximates the desired", + "type": "text" + }, + { + "bbox": [ + 468, + 222, + 487, + 232 + ], + "score": 0.9, + "content": "R _ { w c }", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 221, + 506, + 234 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 232, + 506, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 397, + 245 + ], + "score": 1.0, + "content": "can be computed efficiently with a linear complexity of total timesteps", + "type": "text" + }, + { + "bbox": [ + 397, + 233, + 406, + 242 + ], + "score": 0.69, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 232, + 506, + 245 + ], + "score": 1.0, + "content": ". The idea of GWC is to", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 241, + 504, + 257 + ], + "spans": [ + { + "bbox": [ + 104, + 241, + 485, + 257 + ], + "score": 1.0, + "content": "avoid evaluating exponential numbers of trajectories and use a simple heuristic to approximate", + "type": "text" + }, + { + "bbox": [ + 485, + 243, + 504, + 254 + ], + "score": 0.89, + "content": "R _ { w c }", + "type": "inline_equation" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 253, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 505, + 266 + ], + "score": 1.0, + "content": "by choosing the action with lowest Q-value (or the probability of action taken for A3C) greedily at", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 265, + 506, + 278 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 506, + 278 + ], + "score": 1.0, + "content": "each state. We show in Fig 4 (in Appendix E) that GWC is often close to AWC while being much", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 276, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 505, + 289 + ], + "score": 1.0, + "content": "faster to evaluate (linear complexity of total time steps). Discussion about metrics used in baseline", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 286, + 470, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 470, + 299 + ], + "score": 1.0, + "content": "works [17, 18] and full description of the algorithm for computing AWC is in Appendix D.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 15, + "bbox_fs": [ + 104, + 199, + 506, + 299 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 313, + 233, + 327 + ], + "lines": [ + { + "bbox": [ + 104, + 312, + 234, + 330 + ], + "spans": [ + { + "bbox": [ + 104, + 312, + 234, + 330 + ], + "score": 1.0, + "content": "4 Experimental results", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 338, + 505, + 426 + ], + "lines": [ + { + "bbox": [ + 105, + 339, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 505, + 351 + ], + "score": 1.0, + "content": "Environments and setup To have a fair comparison with baseline works [17, 18], we experiment on", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 350, + 506, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 350, + 506, + 362 + ], + "score": 1.0, + "content": "the same Atari-2600 environment [35] and same 4 games used in [17, 18]. Different from [17, 18],", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 361, + 506, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 506, + 373 + ], + "score": 1.0, + "content": "we further evaluate our algorithm on a more challenging ProcGen [36] benchmark, which allows us", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 371, + 506, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 506, + 383 + ], + "score": 1.0, + "content": "to test generalization abilities of the agent. Note that both Atari-games and ProcGen [36] benchmark", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 383, + 505, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 505, + 395 + ], + "score": 1.0, + "content": "have high dimensional pixel inputs and discrete action spaces. To compare our RL agents with", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 393, + 505, + 406 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 505, + 406 + ], + "score": 1.0, + "content": "continuous actions with [17], we use the MuJoCo environment which simulates robotic control", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "score": 1.0, + "content": "and has relatively low-dimensional inputs and a continuous action space. Full training details and", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 416, + 322, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 322, + 428 + ], + "score": 1.0, + "content": "hyperparameter settings are available in Appendix H.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 24.5, + "bbox_fs": [ + 105, + 339, + 506, + 428 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 431, + 505, + 497 + ], + "lines": [ + { + "bbox": [ + 105, + 431, + 506, + 444 + ], + "spans": [ + { + "bbox": [ + 105, + 431, + 506, + 444 + ], + "score": 1.0, + "content": "Evaluation. We evaluate the performance of our agents with a total of 3 metrics: (a) total reward under", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 441, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 141, + 455 + ], + "score": 1.0, + "content": "10-steps", + "type": "text" + }, + { + "bbox": [ + 142, + 442, + 154, + 453 + ], + "score": 0.87, + "content": "l _ { \\infty }", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 441, + 505, + 455 + ], + "score": 1.0, + "content": "-PGD untargeted attack applied on every frame, (b) GWC and (c) Action Certification", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "score": 1.0, + "content": "Rate (ACR)[17]. For Atari games the result of Approach #2 for RADIAL-agents are in Table 1, and", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 464, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 505, + 477 + ], + "score": 1.0, + "content": "the results of Approach #1 are in Appendix I. Note that A3C and PPO take actions stochastically", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 474, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 506, + 488 + ], + "score": 1.0, + "content": "during training but we set them to deterministically choose the action that has the highest probability", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 486, + 181, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 181, + 500 + ], + "score": 1.0, + "content": "during evaluation.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 31.5, + "bbox_fs": [ + 105, + 431, + 506, + 500 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 510, + 183, + 522 + ], + "lines": [ + { + "bbox": [ + 105, + 509, + 185, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 185, + 523 + ], + "score": 1.0, + "content": "4.1 Atari results", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 106, + 530, + 506, + 673 + ], + "lines": [ + { + "bbox": [ + 105, + 530, + 506, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 506, + 543 + ], + "score": 1.0, + "content": "Table 1 shows that RADIAL-DQN outperforms or matches all the baselines on all four games", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 542, + 506, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 137, + 554 + ], + "score": 1.0, + "content": "against", + "type": "text" + }, + { + "bbox": [ + 138, + 542, + 182, + 554 + ], + "score": 0.91, + "content": "\\epsilon = 1 / 2 5 5", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 542, + 506, + 554 + ], + "score": 1.0, + "content": "PGD-attacks with the same evaluation method in [17]. The result suggests that", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 551, + 506, + 567 + ], + "spans": [ + { + "bbox": [ + 104, + 551, + 279, + 567 + ], + "score": 1.0, + "content": "RADIAL can train a robust policy against", + "type": "text" + }, + { + "bbox": [ + 279, + 552, + 323, + 564 + ], + "score": 0.92, + "content": "\\epsilon = 1 / 2 5 5", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 551, + 506, + 567 + ], + "score": 1.0, + "content": "adversarial perturbations without sacrificing", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 564, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 106, + 564, + 505, + 576 + ], + "score": 1.0, + "content": "nominal performance. In fact, our robust RADIAL agents consistently outperform the baselines on", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 574, + 506, + 587 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 506, + 587 + ], + "score": 1.0, + "content": "all the evaluation metrics, with significant margin in RoadRunner. In addition to better rewards, our", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 585, + 506, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 217, + 598 + ], + "score": 1.0, + "content": "RADIAL-DQN is roughly", + "type": "text" + }, + { + "bbox": [ + 217, + 586, + 231, + 596 + ], + "score": 0.87, + "content": "6 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 232, + 585, + 506, + 598 + ], + "score": 1.0, + "content": "faster to train than [17]. Experimentally if we include the standard", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 596, + 507, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 507, + 609 + ], + "score": 1.0, + "content": "training process, our total run time is only 17 hours compared to SA-DQN’s 35 hours on our hardware.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 607, + 506, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 506, + 620 + ], + "score": 1.0, + "content": "RADIAL-A3C also achieves high rewards under adversarial attacks and beats the baselines on 2/4", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 104, + 616, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 104, + 616, + 506, + 632 + ], + "score": 1.0, + "content": "tasks despite the games likely being chosen by previous work because they are easy for Q-learning", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 104, + 628, + 506, + 642 + ], + "spans": [ + { + "bbox": [ + 104, + 628, + 506, + 642 + ], + "score": 1.0, + "content": "agents. As shown in Table 1 (A3C is excluded because it did not learn Freeway), RADIAL-A3C", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 639, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 505, + 653 + ], + "score": 1.0, + "content": "reaches slightly lower nominal rewards than RADIAL-DQN but shows more robust performance", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 104, + 650, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 104, + 650, + 397, + 664 + ], + "score": 1.0, + "content": "against large perturbations, even outperforming RADIAL-DQN against", + "type": "text" + }, + { + "bbox": [ + 397, + 651, + 438, + 661 + ], + "score": 0.87, + "content": "\\epsilon = 5 / 2 5 5", + "type": "inline_equation" + }, + { + "bbox": [ + 439, + 650, + 506, + 664 + ], + "score": 1.0, + "content": "PGD attacks on", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 662, + 465, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 662, + 465, + 675 + ], + "score": 1.0, + "content": "RoadRunner. This shows RADIAL works well for very different types of RL algorithms.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 42, + "bbox_fs": [ + 104, + 530, + 507, + 675 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 678, + 504, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 678, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 106, + 678, + 506, + 691 + ], + "score": 1.0, + "content": "One interesting finding is that our A3C baseline actually performed well against small PGD-attacks", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 689, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 432, + 702 + ], + "score": 1.0, + "content": "even without robust training (the standard DQN models all perform terribly at", + "type": "text" + }, + { + "bbox": [ + 432, + 689, + 478, + 700 + ], + "score": 0.9, + "content": "\\epsilon = 1 / 2 5 5", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 689, + 506, + 702 + ], + "score": 1.0, + "content": "while", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 699, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 713 + ], + "score": 1.0, + "content": "A3C has comparable or even better performance than the robust trained SA-DQN or RS-DQN.) We", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "believe this is due to two main factors: (a) the network architecture is slightly different from DQN", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 516, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 505, + 529 + ], + "score": 1.0, + "content": "and uses Max-pooling layers, which naturally makes it more resistant against many small changes to", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 528, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 106, + 528, + 505, + 540 + ], + "score": 1.0, + "content": "input; (b) A3C training is more stochastic, so it is more resistant to occasional random actions caused", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 539, + 207, + 551 + ], + "spans": [ + { + "bbox": [ + 106, + 539, + 207, + 551 + ], + "score": 1.0, + "content": "by the untargeted attack.", + "type": "text", + "cross_page": true + } + ], + "index": 9 + } + ], + "index": 50.5, + "bbox_fs": [ + 105, + 678, + 506, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 107, + 69, + 506, + 445 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 107, + 69, + 506, + 445 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 69, + 506, + 445 + ], + "spans": [ + { + "bbox": [ + 107, + 69, + 506, + 445 + ], + "score": 0.98, + "html": "
Model/metricNominalPGD attackGWCACR
E01/2553/2555/2551/2551/255
BankHeist
Baselines:
StandardDQN[17] A3C1325.5±5.7 1109.0±21.429.5±2.4 1102.5±49.40.0±0.00.0±0.00.0±0.0 0.5±0.50.000 0.000
RobustRS-DQN[18]238.66190.67534.5±58.2 N/A115.0±27.8 N/AN/AN/A
SA-DQN[17]1237.6±1.71237.0±2.01213.0±2.51130.0±29.11196.5±9.40.976
Our Methods:
RADIAL-DQN1349.5±1.71349.5±1.71348±1.71182.5±43.31344.5±1.80.981
RADIAL-A3C1036.5±23.4975±22.2949±19.5712±46.4851.5±2.90.718
Freeway Baselines:
StandardDQN[17]33.9±0.070.0±0.00.0±0.00.0±0.00.0±0.00.000
RobustRS-DQN[18]32.9332.53N/AN/AN/AN/A
SA-DQN [17]30.0±0.030.0±0.030.05±0.0527.65±0.2230.0±0.01.000
Our Methods:
RADIAL-DQN33.2±0.1933.35±0.1633.4±0.1329.1±0.1733.25±0.240.998
Pong Baselines:
StandardDQN[17]21.0±0.0-21.0±0.0-21.0±0.0-20.85±0.08-21.0±0.00.000
RobustA3C21.0±0.021.0±0.021.0±0.0-17.85±0.33-21.0±0.00.000
RS-DQN[18] SA-DQN[17]19.73 21.0±0.018.13 21.0±0.0N/A 21.0±0.0N/A -19.75±0.1N/A 21.0±0.0N/A 1.000
Our Methods:
21.0±0.021.0±0.021.0±0.021.0±0.021.0±0.0
RADIAL-DQN RADIAL-A3C21.0±0.021.0±0.021.0±0.021.0±0.021.0±0.00.894 0.755
RoadRunner
Standard
DQN[17] A3C43390±973 34420±6040.0±0.0 31040±21730.0±0.0 3025±3170.0±0.0 350±930.0±0.0 0.0±0.00.000 0.000
RobustRS-DQN[18]12106.675753.33N/AN/AN/AN/A
SA-DQN [17]45870±138044300±175320170±18223350±3350.0±0.00.602
Our Methods:
RADIAL-DQN44495±116544445±114839560±162123820±94245770±16220.994
RADIAL-A3C34825±98131960±93329920±149631545±148031885±19120.923
", + "type": "table", + "image_path": "eb0684095f8c4ed42a4e1a770d041f72780f92f5e554e3b9d4a7c1b2ad90464e.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 107, + 69, + 506, + 194.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 107, + 194.33333333333331, + 506, + 319.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 107, + 319.66666666666663, + 506, + 444.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 106, + 449, + 505, + 493 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 449, + 506, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 449, + 506, + 461 + ], + "score": 1.0, + "content": "Table 1: We report the mean reward of 20 runs as well as the standard error of the mean(sem). Best", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 460, + 505, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 505, + 472 + ], + "score": 1.0, + "content": "result boldfaced, results within a sem of the best result underlined. RADIAL-DQN outperforms all", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 471, + 505, + 483 + ], + "spans": [ + { + "bbox": [ + 106, + 471, + 320, + 483 + ], + "score": 1.0, + "content": "the baselines. All the robust models are trained with", + "type": "text" + }, + { + "bbox": [ + 320, + 471, + 364, + 483 + ], + "score": 0.87, + "content": "\\epsilon = 1 / 2 5 5", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 471, + 505, + 483 + ], + "score": 1.0, + "content": ". RS-DQN results are N/A besides", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 482, + 348, + 493 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 348, + 493 + ], + "score": 1.0, + "content": "1/255 PGD as the authors have not released code or models.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "text", + "bbox": [ + 107, + 516, + 504, + 550 + ], + "lines": [ + { + "bbox": [ + 105, + 516, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 505, + 529 + ], + "score": 1.0, + "content": "and uses Max-pooling layers, which naturally makes it more resistant against many small changes to", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 528, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 106, + 528, + 505, + 540 + ], + "score": 1.0, + "content": "input; (b) A3C training is more stochastic, so it is more resistant to occasional random actions caused", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 539, + 207, + 551 + ], + "spans": [ + { + "bbox": [ + 106, + 539, + 207, + 551 + ], + "score": 1.0, + "content": "by the untargeted attack.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 565, + 505, + 654 + ], + "lines": [ + { + "bbox": [ + 105, + 565, + 506, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 506, + 579 + ], + "score": 1.0, + "content": "Another interesting observation in our experiments across different algorithms and environments is", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 577, + 506, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 589 + ], + "score": 1.0, + "content": "that sometimes applying an attack or increasing the magnitude of PGD-attack increases the reward", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 587, + 505, + 600 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 505, + 600 + ], + "score": 1.0, + "content": "achieved. We note that this phenomenon is not unreasonable since the PGD attack is designed to", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 597, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 505, + 612 + ], + "score": 1.0, + "content": "simply change original actions of RL agent; it is possible and often even likely that original trajectory", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 610, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 505, + 622 + ], + "score": 1.0, + "content": "was not the best possible one and a different trajectory can give higher reward. We observed this", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 620, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 620, + 505, + 632 + ], + "score": 1.0, + "content": "phenomenon on Freeway for both SA-DQN and RADIAL-DQN (Table 1), and for RADIAL-PPO", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 632, + 504, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 504, + 644 + ], + "score": 1.0, + "content": "on CoinRun and Jumper (Table 2). We believe this indicates the weakness of untargeted PGD-attacks", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 643, + 364, + 655 + ], + "spans": [ + { + "bbox": [ + 106, + 643, + 364, + 655 + ], + "score": 1.0, + "content": "and highlights room for improvement of attacks on RL-policies.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 13.5 + }, + { + "type": "title", + "bbox": [ + 108, + 668, + 201, + 679 + ], + "lines": [ + { + "bbox": [ + 105, + 667, + 203, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 203, + 681 + ], + "score": 1.0, + "content": "4.2 ProcGen Results", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 689, + 504, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 689, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 506, + 701 + ], + "score": 1.0, + "content": "We report our results on 3 environments on the ProcGen benchmark [36] in Table 2. To our best", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "knowledge, it is the first evaluation of robustness of RL-agents trained on ProcGen. All our agents", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 711, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 506, + 722 + ], + "score": 1.0, + "content": "were trained for 25M steps on the easy setting, trained on 200 different levels and evaluated on the", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 742, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "score": 1.0, + "content": "8", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 107, + 69, + 506, + 445 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 107, + 69, + 506, + 445 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 69, + 506, + 445 + ], + "spans": [ + { + "bbox": [ + 107, + 69, + 506, + 445 + ], + "score": 0.98, + "html": "
Model/metricNominalPGD attackGWCACR
E01/2553/2555/2551/2551/255
BankHeist
Baselines:
StandardDQN[17] A3C1325.5±5.7 1109.0±21.429.5±2.4 1102.5±49.40.0±0.00.0±0.00.0±0.0 0.5±0.50.000 0.000
RobustRS-DQN[18]238.66190.67534.5±58.2 N/A115.0±27.8 N/AN/AN/A
SA-DQN[17]1237.6±1.71237.0±2.01213.0±2.51130.0±29.11196.5±9.40.976
Our Methods:
RADIAL-DQN1349.5±1.71349.5±1.71348±1.71182.5±43.31344.5±1.80.981
RADIAL-A3C1036.5±23.4975±22.2949±19.5712±46.4851.5±2.90.718
Freeway Baselines:
StandardDQN[17]33.9±0.070.0±0.00.0±0.00.0±0.00.0±0.00.000
RobustRS-DQN[18]32.9332.53N/AN/AN/AN/A
SA-DQN [17]30.0±0.030.0±0.030.05±0.0527.65±0.2230.0±0.01.000
Our Methods:
RADIAL-DQN33.2±0.1933.35±0.1633.4±0.1329.1±0.1733.25±0.240.998
Pong Baselines:
StandardDQN[17]21.0±0.0-21.0±0.0-21.0±0.0-20.85±0.08-21.0±0.00.000
RobustA3C21.0±0.021.0±0.021.0±0.0-17.85±0.33-21.0±0.00.000
RS-DQN[18] SA-DQN[17]19.73 21.0±0.018.13 21.0±0.0N/A 21.0±0.0N/A -19.75±0.1N/A 21.0±0.0N/A 1.000
Our Methods:
21.0±0.021.0±0.021.0±0.021.0±0.021.0±0.0
RADIAL-DQN RADIAL-A3C21.0±0.021.0±0.021.0±0.021.0±0.021.0±0.00.894 0.755
RoadRunner
Standard
DQN[17] A3C43390±973 34420±6040.0±0.0 31040±21730.0±0.0 3025±3170.0±0.0 350±930.0±0.0 0.0±0.00.000 0.000
RobustRS-DQN[18]12106.675753.33N/AN/AN/AN/A
SA-DQN [17]45870±138044300±175320170±18223350±3350.0±0.00.602
Our Methods:
RADIAL-DQN44495±116544445±114839560±162123820±94245770±16220.994
RADIAL-A3C34825±98131960±93329920±149631545±148031885±19120.923
", + "type": "table", + "image_path": "eb0684095f8c4ed42a4e1a770d041f72780f92f5e554e3b9d4a7c1b2ad90464e.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 107, + 69, + 506, + 194.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 107, + 194.33333333333331, + 506, + 319.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 107, + 319.66666666666663, + 506, + 444.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 106, + 449, + 505, + 493 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 449, + 506, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 449, + 506, + 461 + ], + "score": 1.0, + "content": "Table 1: We report the mean reward of 20 runs as well as the standard error of the mean(sem). Best", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 460, + 505, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 505, + 472 + ], + "score": 1.0, + "content": "result boldfaced, results within a sem of the best result underlined. RADIAL-DQN outperforms all", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 471, + 505, + 483 + ], + "spans": [ + { + "bbox": [ + 106, + 471, + 320, + 483 + ], + "score": 1.0, + "content": "the baselines. All the robust models are trained with", + "type": "text" + }, + { + "bbox": [ + 320, + 471, + 364, + 483 + ], + "score": 0.87, + "content": "\\epsilon = 1 / 2 5 5", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 471, + 505, + 483 + ], + "score": 1.0, + "content": ". RS-DQN results are N/A besides", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 482, + 348, + 493 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 348, + 493 + ], + "score": 1.0, + "content": "1/255 PGD as the authors have not released code or models.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "text", + "bbox": [ + 107, + 516, + 504, + 550 + ], + "lines": [], + "index": 8, + "bbox_fs": [ + 105, + 516, + 505, + 551 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 565, + 505, + 654 + ], + "lines": [ + { + "bbox": [ + 105, + 565, + 506, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 506, + 579 + ], + "score": 1.0, + "content": "Another interesting observation in our experiments across different algorithms and environments is", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 577, + 506, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 589 + ], + "score": 1.0, + "content": "that sometimes applying an attack or increasing the magnitude of PGD-attack increases the reward", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 587, + 505, + 600 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 505, + 600 + ], + "score": 1.0, + "content": "achieved. We note that this phenomenon is not unreasonable since the PGD attack is designed to", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 597, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 505, + 612 + ], + "score": 1.0, + "content": "simply change original actions of RL agent; it is possible and often even likely that original trajectory", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 610, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 505, + 622 + ], + "score": 1.0, + "content": "was not the best possible one and a different trajectory can give higher reward. We observed this", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 620, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 620, + 505, + 632 + ], + "score": 1.0, + "content": "phenomenon on Freeway for both SA-DQN and RADIAL-DQN (Table 1), and for RADIAL-PPO", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 632, + 504, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 504, + 644 + ], + "score": 1.0, + "content": "on CoinRun and Jumper (Table 2). We believe this indicates the weakness of untargeted PGD-attacks", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 643, + 364, + 655 + ], + "spans": [ + { + "bbox": [ + 106, + 643, + 364, + 655 + ], + "score": 1.0, + "content": "and highlights room for improvement of attacks on RL-policies.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 13.5, + "bbox_fs": [ + 105, + 565, + 506, + 655 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 668, + 201, + 679 + ], + "lines": [ + { + "bbox": [ + 105, + 667, + 203, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 203, + 681 + ], + "score": 1.0, + "content": "4.2 ProcGen Results", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 689, + 504, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 689, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 506, + 701 + ], + "score": 1.0, + "content": "We report our results on 3 environments on the ProcGen benchmark [36] in Table 2. To our best", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "knowledge, it is the first evaluation of robustness of RL-agents trained on ProcGen. All our agents", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 711, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 506, + 722 + ], + "score": 1.0, + "content": "were trained for 25M steps on the easy setting, trained on 200 different levels and evaluated on the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 483, + 505, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 505, + 496 + ], + "score": 1.0, + "content": "full distribution. We used the IMPALA-CNN architecture [36], which is a significantly larger than", + "type": "text", + "cross_page": true + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 494, + 504, + 506 + ], + "spans": [ + { + "bbox": [ + 106, + 494, + 504, + 506 + ], + "score": 1.0, + "content": "the ones in our Atari experiments, but our algorithm and training setup can still successfully scale", + "type": "text", + "cross_page": true + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 505, + 506, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 506, + 518 + ], + "score": 1.0, + "content": "to this more complex setting. We notice like A3C, the original PPO-policy is already quite robust", + "type": "text", + "cross_page": true + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 516, + 506, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 516, + 506, + 529 + ], + "score": 1.0, + "content": "against small PGD-attacks, but RADIAL-PPO has even better robustness to much stronger attacks.", + "type": "text", + "cross_page": true + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 526, + 506, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 506, + 541 + ], + "score": 1.0, + "content": "Next, we use the train/evaluation split in levels to study whether our robust training generalizes to", + "type": "text", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 538, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 505, + 550 + ], + "score": 1.0, + "content": "new environments. We observe that RADIAL training increases robustness consistently on both", + "type": "text", + "cross_page": true + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 549, + 506, + 562 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 506, + 562 + ], + "score": 1.0, + "content": "training and evaluation set, and the gap between training and evaluation results is often smaller for", + "type": "text", + "cross_page": true + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 559, + 506, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 559, + 506, + 573 + ], + "score": 1.0, + "content": "RADIAL-PPO. The results in Table 2 uses a deterministic version of the policy and the result of", + "type": "text", + "cross_page": true + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 571, + 281, + 583 + ], + "spans": [ + { + "bbox": [ + 106, + 571, + 281, + 583 + ], + "score": 1.0, + "content": "stochastic policy is reported in Appendix I.", + "type": "text", + "cross_page": true + } + ], + "index": 19 + } + ], + "index": 20, + "bbox_fs": [ + 105, + 689, + 506, + 722 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 143, + 70, + 469, + 215 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 143, + 70, + 469, + 215 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 143, + 70, + 469, + 215 + ], + "spans": [ + { + "bbox": [ + 143, + 70, + 469, + 215 + ], + "score": 0.982, + "html": "
Env:ModelDistNominale=1/255 PGDe=3/255PGDe=5/255 PGD
FruitbotPPOTrain30.20±0.2325.72 ± 0.3315.56 ± 0.388.79 ± 0.35
RADIAL-PPOEval26.09 ± 0.3322.53 ± 0.3813.51 ± 0.398.51 ± 0.35
Train28.03±0.2427.93 ± 0.2527.84 ± 0.2627.50 ± 0.26
Eval26.08 ± 0.2926.06 ± 0.3025.87 ± 0.3025.81 ± 0.30
CoinrunPPOTrain8.31± 0.126.36± 0.154.19 ± 0.163.32 ±0.15
Eval6.65 ± 0.155.22 ± 0.163.58 ± 0.153.36 ± 0.15
RADIAL-PPOTrain7.12 ±0.147.10 ±0.147.19 ± 0.147.34± 0.14
Eval6.66 ± 0.156.71 ± 0.156.71 ± 0.156.67 ± 0.15
JumperPPOTrain8.69± 0.116.61 ± 0.154.50 ± 0.163.42 ± 0.15
RADIAL-PPOEval4.22 ± 0.163.90 ± 0.153.10 ± 0.153.15 ± 0.15
Train6.59 ± 0.156.70 ± 0.156.55 ± 0.156.83 ± 0.15
Eval3.85 ± 0.153.93 ± 0.153.75 ± 0.153.59 ± 0.15
", + "type": "table", + "image_path": "9e612535553db477a75e3961cd4396da78cd4fd95d3ced722f5e23df834d7edf.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 143, + 70, + 469, + 118.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 143, + 118.33333333333334, + 469, + 166.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 143, + 166.66666666666669, + 469, + 215.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 105, + 222, + 505, + 245 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 221, + 505, + 235 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 505, + 235 + ], + "score": 1.0, + "content": "Table 2: Results on the ProcGen environments. Each model was evaluated for 1000 episodes on the", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 233, + 433, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 233, + 433, + 245 + ], + "score": 1.0, + "content": "training/evaluation set. Reported means together with standard error of the mean.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "table", + "bbox": [ + 134, + 275, + 477, + 403 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 134, + 275, + 477, + 403 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 134, + 275, + 477, + 403 + ], + "spans": [ + { + "bbox": [ + 134, + 275, + 477, + 403 + ], + "score": 0.982, + "html": "
EnvironmentModelNominal e=0e = 0.0375Attack (MAD) e= 0.075∈=0.15
Walker2D (etrain = 0.075)PPO3635.3±50.71968.5±90.61283.1±61.9670.3±31.9
SA-PPO [17]3776.4±186.03923.6±189.93263.7±228.13652.1±203.3
RADIAL-PPO5251.6±10.45108.4±67.94474.7±140.63895.3±128.3
Hopper (etrain = 0.075)PPO2740.7±125.82034.4±126.91524.2±146.3969.9±90.1
SA-PPO [17]3585.0±56.43364.7±93.93165.1±107.12248.3±124.7
RADIAL-PPO3737.5±4.43684.9±27.43252.1±101.92498.9±130.0
Half Cheetah (etrain = 0.15)PPO5566.0±8.75517.8±8.85179.3±64.71483.6±193.4
SA-PPO [17]4175.0±29.94168.8±29.94178.5±35.34173.1±31.8
RADIAL-PPO4724.3±10.64629.7±36.94480.0±66.94008.5±119.5
", + "type": "table", + "image_path": "0c635eda1a4941cceb73e2da4eb0361f39f277096b8fd68e831e52a3d0fa1669.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 134, + 275, + 477, + 317.6666666666667 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 134, + 317.6666666666667, + 477, + 360.33333333333337 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 134, + 360.33333333333337, + 477, + 403.00000000000006 + ], + "spans": [], + "index": 7 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 106, + 416, + 506, + 450 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 415, + 506, + 429 + ], + "spans": [ + { + "bbox": [ + 104, + 415, + 304, + 429 + ], + "score": 1.0, + "content": "Table 3: We report the results of reward (mean", + "type": "text" + }, + { + "bbox": [ + 304, + 417, + 315, + 427 + ], + "score": 0.64, + "content": "\\pm", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 415, + 506, + 429 + ], + "score": 1.0, + "content": "standard error of the mean) for each agent in", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 426, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 505, + 439 + ], + "score": 1.0, + "content": "MuJoCo continuous control tasks. Agents are trained for 4096k steps and evaluated for 50 episodes", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 439, + 473, + 450 + ], + "spans": [ + { + "bbox": [ + 106, + 439, + 473, + 450 + ], + "score": 1.0, + "content": "on the evaluation set. Results within standard error of the mean from best result underlined.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 106, + 483, + 505, + 582 + ], + "lines": [ + { + "bbox": [ + 105, + 483, + 505, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 505, + 496 + ], + "score": 1.0, + "content": "full distribution. We used the IMPALA-CNN architecture [36], which is a significantly larger than", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 494, + 504, + 506 + ], + "spans": [ + { + "bbox": [ + 106, + 494, + 504, + 506 + ], + "score": 1.0, + "content": "the ones in our Atari experiments, but our algorithm and training setup can still successfully scale", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 505, + 506, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 506, + 518 + ], + "score": 1.0, + "content": "to this more complex setting. We notice like A3C, the original PPO-policy is already quite robust", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 516, + 506, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 516, + 506, + 529 + ], + "score": 1.0, + "content": "against small PGD-attacks, but RADIAL-PPO has even better robustness to much stronger attacks.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 526, + 506, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 506, + 541 + ], + "score": 1.0, + "content": "Next, we use the train/evaluation split in levels to study whether our robust training generalizes to", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 538, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 505, + 550 + ], + "score": 1.0, + "content": "new environments. We observe that RADIAL training increases robustness consistently on both", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 549, + 506, + 562 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 506, + 562 + ], + "score": 1.0, + "content": "training and evaluation set, and the gap between training and evaluation results is often smaller for", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 559, + 506, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 559, + 506, + 573 + ], + "score": 1.0, + "content": "RADIAL-PPO. The results in Table 2 uses a deterministic version of the policy and the result of", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 571, + 281, + 583 + ], + "spans": [ + { + "bbox": [ + 106, + 571, + 281, + 583 + ], + "score": 1.0, + "content": "stochastic policy is reported in Appendix I.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 15 + }, + { + "type": "title", + "bbox": [ + 107, + 608, + 201, + 620 + ], + "lines": [ + { + "bbox": [ + 105, + 606, + 202, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 202, + 622 + ], + "score": 1.0, + "content": "4.3 MuJoCo Results", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 106, + 634, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 635, + 505, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 505, + 646 + ], + "score": 1.0, + "content": "In Table 3 we show our results on 3 environments from MuJoCo [37] and comparison with vanilla", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "score": 1.0, + "content": "PPO method and SA-PPO [17] convex relaxation approach. We directly use the implementation from", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 656, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 163, + 668 + ], + "score": 1.0, + "content": "[17]. We train", + "type": "text" + }, + { + "bbox": [ + 163, + 656, + 191, + 667 + ], + "score": 0.59, + "content": "4 0 9 6 \\mathrm { k \\Omega }", + "type": "inline_equation" + }, + { + "bbox": [ + 192, + 657, + 505, + 668 + ], + "score": 1.0, + "content": "steps for all 3 environments, whereas [17] uses roughly 2000k for Walker2D and", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "score": 1.0, + "content": "Hopper. For each environment, we compare the performance under MAD attacks [17] with different", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 677, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 248, + 691 + ], + "score": 1.0, + "content": "\u000f. For Walker2D, we use training", + "type": "text" + }, + { + "bbox": [ + 249, + 678, + 289, + 688 + ], + "score": 0.88, + "content": "\\epsilon = 0 . 0 7 5", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 677, + 334, + 691 + ], + "score": 1.0, + "content": "instead of", + "type": "text" + }, + { + "bbox": [ + 334, + 678, + 369, + 688 + ], + "score": 0.88, + "content": "\\epsilon = 0 . 0 5", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 677, + 505, + 691 + ], + "score": 1.0, + "content": "from [17] for better comparison", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 688, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 505, + 701 + ], + "score": 1.0, + "content": "under different attacks. For Walker2D and Hopper, RADIAL-PPO outperforms SA-PPO [17] in", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 700, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 700, + 506, + 712 + ], + "score": 1.0, + "content": "both natural testing and robust testing. Interesting, for Half-Cheetah, we found this environment is", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 710, + 446, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 408, + 723 + ], + "score": 1.0, + "content": "naturally robust (even better than robust trained agents) against attack up to", + "type": "text" + }, + { + "bbox": [ + 409, + 711, + 442, + 721 + ], + "score": 0.86, + "content": "\\scriptstyle \\epsilon = 0 . 0 7 5", + "type": "inline_equation" + }, + { + "bbox": [ + 442, + 710, + 446, + 723 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 24.5 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 143, + 70, + 469, + 215 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 143, + 70, + 469, + 215 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 143, + 70, + 469, + 215 + ], + "spans": [ + { + "bbox": [ + 143, + 70, + 469, + 215 + ], + "score": 0.982, + "html": "
Env:ModelDistNominale=1/255 PGDe=3/255PGDe=5/255 PGD
FruitbotPPOTrain30.20±0.2325.72 ± 0.3315.56 ± 0.388.79 ± 0.35
RADIAL-PPOEval26.09 ± 0.3322.53 ± 0.3813.51 ± 0.398.51 ± 0.35
Train28.03±0.2427.93 ± 0.2527.84 ± 0.2627.50 ± 0.26
Eval26.08 ± 0.2926.06 ± 0.3025.87 ± 0.3025.81 ± 0.30
CoinrunPPOTrain8.31± 0.126.36± 0.154.19 ± 0.163.32 ±0.15
Eval6.65 ± 0.155.22 ± 0.163.58 ± 0.153.36 ± 0.15
RADIAL-PPOTrain7.12 ±0.147.10 ±0.147.19 ± 0.147.34± 0.14
Eval6.66 ± 0.156.71 ± 0.156.71 ± 0.156.67 ± 0.15
JumperPPOTrain8.69± 0.116.61 ± 0.154.50 ± 0.163.42 ± 0.15
RADIAL-PPOEval4.22 ± 0.163.90 ± 0.153.10 ± 0.153.15 ± 0.15
Train6.59 ± 0.156.70 ± 0.156.55 ± 0.156.83 ± 0.15
Eval3.85 ± 0.153.93 ± 0.153.75 ± 0.153.59 ± 0.15
", + "type": "table", + "image_path": "9e612535553db477a75e3961cd4396da78cd4fd95d3ced722f5e23df834d7edf.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 143, + 70, + 469, + 118.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 143, + 118.33333333333334, + 469, + 166.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 143, + 166.66666666666669, + 469, + 215.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 105, + 222, + 505, + 245 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 221, + 505, + 235 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 505, + 235 + ], + "score": 1.0, + "content": "Table 2: Results on the ProcGen environments. Each model was evaluated for 1000 episodes on the", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 233, + 433, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 233, + 433, + 245 + ], + "score": 1.0, + "content": "training/evaluation set. Reported means together with standard error of the mean.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "table", + "bbox": [ + 134, + 275, + 477, + 403 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 134, + 275, + 477, + 403 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 134, + 275, + 477, + 403 + ], + "spans": [ + { + "bbox": [ + 134, + 275, + 477, + 403 + ], + "score": 0.982, + "html": "
EnvironmentModelNominal e=0e = 0.0375Attack (MAD) e= 0.075∈=0.15
Walker2D (etrain = 0.075)PPO3635.3±50.71968.5±90.61283.1±61.9670.3±31.9
SA-PPO [17]3776.4±186.03923.6±189.93263.7±228.13652.1±203.3
RADIAL-PPO5251.6±10.45108.4±67.94474.7±140.63895.3±128.3
Hopper (etrain = 0.075)PPO2740.7±125.82034.4±126.91524.2±146.3969.9±90.1
SA-PPO [17]3585.0±56.43364.7±93.93165.1±107.12248.3±124.7
RADIAL-PPO3737.5±4.43684.9±27.43252.1±101.92498.9±130.0
Half Cheetah (etrain = 0.15)PPO5566.0±8.75517.8±8.85179.3±64.71483.6±193.4
SA-PPO [17]4175.0±29.94168.8±29.94178.5±35.34173.1±31.8
RADIAL-PPO4724.3±10.64629.7±36.94480.0±66.94008.5±119.5
", + "type": "table", + "image_path": "0c635eda1a4941cceb73e2da4eb0361f39f277096b8fd68e831e52a3d0fa1669.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 134, + 275, + 477, + 317.6666666666667 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 134, + 317.6666666666667, + 477, + 360.33333333333337 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 134, + 360.33333333333337, + 477, + 403.00000000000006 + ], + "spans": [], + "index": 7 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 106, + 416, + 506, + 450 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 415, + 506, + 429 + ], + "spans": [ + { + "bbox": [ + 104, + 415, + 304, + 429 + ], + "score": 1.0, + "content": "Table 3: We report the results of reward (mean", + "type": "text" + }, + { + "bbox": [ + 304, + 417, + 315, + 427 + ], + "score": 0.64, + "content": "\\pm", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 415, + 506, + 429 + ], + "score": 1.0, + "content": "standard error of the mean) for each agent in", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 426, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 505, + 439 + ], + "score": 1.0, + "content": "MuJoCo continuous control tasks. Agents are trained for 4096k steps and evaluated for 50 episodes", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 439, + 473, + 450 + ], + "spans": [ + { + "bbox": [ + 106, + 439, + 473, + 450 + ], + "score": 1.0, + "content": "on the evaluation set. Results within standard error of the mean from best result underlined.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 106, + 483, + 505, + 582 + ], + "lines": [], + "index": 15, + "bbox_fs": [ + 105, + 483, + 506, + 583 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 107, + 608, + 201, + 620 + ], + "lines": [ + { + "bbox": [ + 105, + 606, + 202, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 202, + 622 + ], + "score": 1.0, + "content": "4.3 MuJoCo Results", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 106, + 634, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 635, + 505, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 505, + 646 + ], + "score": 1.0, + "content": "In Table 3 we show our results on 3 environments from MuJoCo [37] and comparison with vanilla", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "score": 1.0, + "content": "PPO method and SA-PPO [17] convex relaxation approach. We directly use the implementation from", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 656, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 163, + 668 + ], + "score": 1.0, + "content": "[17]. We train", + "type": "text" + }, + { + "bbox": [ + 163, + 656, + 191, + 667 + ], + "score": 0.59, + "content": "4 0 9 6 \\mathrm { k \\Omega }", + "type": "inline_equation" + }, + { + "bbox": [ + 192, + 657, + 505, + 668 + ], + "score": 1.0, + "content": "steps for all 3 environments, whereas [17] uses roughly 2000k for Walker2D and", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "score": 1.0, + "content": "Hopper. For each environment, we compare the performance under MAD attacks [17] with different", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 677, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 248, + 691 + ], + "score": 1.0, + "content": "\u000f. For Walker2D, we use training", + "type": "text" + }, + { + "bbox": [ + 249, + 678, + 289, + 688 + ], + "score": 0.88, + "content": "\\epsilon = 0 . 0 7 5", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 677, + 334, + 691 + ], + "score": 1.0, + "content": "instead of", + "type": "text" + }, + { + "bbox": [ + 334, + 678, + 369, + 688 + ], + "score": 0.88, + "content": "\\epsilon = 0 . 0 5", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 677, + 505, + 691 + ], + "score": 1.0, + "content": "from [17] for better comparison", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 688, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 505, + 701 + ], + "score": 1.0, + "content": "under different attacks. For Walker2D and Hopper, RADIAL-PPO outperforms SA-PPO [17] in", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 700, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 700, + 506, + 712 + ], + "score": 1.0, + "content": "both natural testing and robust testing. Interesting, for Half-Cheetah, we found this environment is", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 710, + 446, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 408, + 723 + ], + "score": 1.0, + "content": "naturally robust (even better than robust trained agents) against attack up to", + "type": "text" + }, + { + "bbox": [ + 409, + 711, + 442, + 721 + ], + "score": 0.86, + "content": "\\scriptstyle \\epsilon = 0 . 0 7 5", + "type": "inline_equation" + }, + { + "bbox": [ + 442, + 710, + 446, + 723 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 24.5, + "bbox_fs": [ + 105, + 635, + 506, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 72, + 204, + 84 + ], + "lines": [ + { + "bbox": [ + 105, + 70, + 206, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 70, + 206, + 86 + ], + "score": 1.0, + "content": "4.4 Evaluating GWC", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 106, + 92, + 505, + 224 + ], + "lines": [ + { + "bbox": [ + 105, + 92, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 105, + 92, + 505, + 105 + ], + "score": 1.0, + "content": "We show empirically that GWC is indeed a good approximation of AWC reward. We compare GWC", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 103, + 505, + 115 + ], + "spans": [ + { + "bbox": [ + 105, + 103, + 505, + 115 + ], + "score": 1.0, + "content": "and action certification rate (ACR) against the Absolute Worst-Case Reward (AWC) on a small", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 115, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 505, + 127 + ], + "score": 1.0, + "content": "scale experiments on reaching the first reward within 80 frames on Freeway due to the exponential", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 125, + 506, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 125, + 408, + 138 + ], + "score": 1.0, + "content": "complexity of AWC. Figure is available in Appendix D. GWC is the ratio of", + "type": "text" + }, + { + "bbox": [ + 408, + 126, + 420, + 136 + ], + "score": 0.84, + "content": "+ 1", + "type": "inline_equation" + }, + { + "bbox": [ + 420, + 125, + 506, + 138 + ], + "score": 1.0, + "content": "rewards as measured", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 137, + 505, + 149 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 393, + 149 + ], + "score": 1.0, + "content": "by GWC, while AWC uses depth first search to compute the percentage of", + "type": "text" + }, + { + "bbox": [ + 394, + 137, + 405, + 146 + ], + "score": 0.85, + "content": "+ 1", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 137, + 505, + 149 + ], + "score": 1.0, + "content": "rewards using Algorithm", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 146, + 506, + 160 + ], + "spans": [ + { + "bbox": [ + 104, + 146, + 348, + 160 + ], + "score": 1.0, + "content": "2 (i.e. where all possible sequences of actions get at least", + "type": "text" + }, + { + "bbox": [ + 349, + 148, + 361, + 158 + ], + "score": 0.81, + "content": "+ 1", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 146, + 506, + 160 + ], + "score": 1.0, + "content": "reward). For the episodes that we", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 158, + 506, + 171 + ], + "spans": [ + { + "bbox": [ + 105, + 158, + 293, + 171 + ], + "score": 1.0, + "content": "evaluated, GWC matched AWC perfectly for", + "type": "text" + }, + { + "bbox": [ + 293, + 158, + 368, + 169 + ], + "score": 0.9, + "content": "\\epsilon \\in \\{ 1 . 0 , 1 . 2 , 1 . 5 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 368, + 158, + 506, + 171 + ], + "score": 1.0, + "content": ". Since AWC is a lower bound of", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 169, + 503, + 181 + ], + "spans": [ + { + "bbox": [ + 106, + 169, + 149, + 181 + ], + "score": 1.0, + "content": "GWC, for", + "type": "text" + }, + { + "bbox": [ + 149, + 169, + 206, + 181 + ], + "score": 0.92, + "content": "\\epsilon \\in \\{ 1 . 3 , 1 . 4 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 206, + 169, + 484, + 181 + ], + "score": 1.0, + "content": "GWC matched AWC on 37/40 episodes, while overestimating on the", + "type": "text" + }, + { + "bbox": [ + 484, + 169, + 503, + 180 + ], + "score": 0.28, + "content": "3 / 4 0", + "type": "inline_equation" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 179, + 506, + 192 + ], + "spans": [ + { + "bbox": [ + 105, + 179, + 506, + 192 + ], + "score": 1.0, + "content": "ACR (as used in [17]) did not show as strong of a correlation with AWC. As evident in Table 1, GWC", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 104, + 190, + 506, + 204 + ], + "spans": [ + { + "bbox": [ + 104, + 190, + 506, + 204 + ], + "score": 1.0, + "content": "is a better indicator for the robust performance than ACR – this is the case for Freeway and Pong", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 201, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 105, + 201, + 505, + 213 + ], + "score": 1.0, + "content": "where SA-DQN has higher action certification rates but RADIAL-DQN has higher GWC and PGD", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 213, + 441, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 213, + 441, + 225 + ], + "score": 1.0, + "content": "rewards. Together these results give faith in GWC being a good evaluation method.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 6.5 + }, + { + "type": "title", + "bbox": [ + 108, + 239, + 282, + 252 + ], + "lines": [ + { + "bbox": [ + 104, + 237, + 283, + 254 + ], + "spans": [ + { + "bbox": [ + 104, + 237, + 283, + 254 + ], + "score": 1.0, + "content": "5 Conclusions and Future works", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 263, + 505, + 362 + ], + "lines": [ + { + "bbox": [ + 105, + 262, + 506, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 506, + 276 + ], + "score": 1.0, + "content": "We have shown that using the proposed RADIAL framework can significantly improve the robustness", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 273, + 506, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 506, + 288 + ], + "score": 1.0, + "content": "of deep RL agents against adversarial perturbations based on robustness verification bounds – our", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 285, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 384, + 298 + ], + "score": 1.0, + "content": "robustly trained agents reach very good performance against even", + "type": "text" + }, + { + "bbox": [ + 384, + 286, + 399, + 296 + ], + "score": 0.85, + "content": "5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 285, + 505, + 298 + ], + "score": 1.0, + "content": "larger perturbations than", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 296, + 506, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 506, + 309 + ], + "score": 1.0, + "content": "previous state of the art, and in the meantime are much more computationally efficient to train.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 307, + 506, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 506, + 321 + ], + "score": 1.0, + "content": "In addition, we have presented a new evaluation method, Greedy Worst-Case Reward, as a good", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 318, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 318, + 505, + 331 + ], + "score": 1.0, + "content": "surrogate of the worst-case reward to evaluate deep RL agent’s performance under adversarial", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 329, + 505, + 342 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 505, + 342 + ], + "score": 1.0, + "content": "input perturbations. Future works include extending our framework to defend against semantic", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 339, + 506, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 506, + 353 + ], + "score": 1.0, + "content": "perturbations such as contrast and brightness changes, which are more realistic on the vision-based", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 351, + 322, + 363 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 322, + 363 + ], + "score": 1.0, + "content": "RL agents (e.g. self-driving car, vision-based robots).", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 18 + }, + { + "type": "title", + "bbox": [ + 107, + 377, + 339, + 390 + ], + "lines": [ + { + "bbox": [ + 104, + 375, + 341, + 393 + ], + "spans": [ + { + "bbox": [ + 104, + 375, + 341, + 393 + ], + "score": 1.0, + "content": "6 Limitations and Potential negative impact", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 402, + 505, + 478 + ], + "lines": [ + { + "bbox": [ + 105, + 402, + 506, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 506, + 415 + ], + "score": 1.0, + "content": "An important limitation of our work and one that may cause negative impact in the future is that our", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 413, + 507, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 379, + 425 + ], + "score": 1.0, + "content": "work addresses only a specific axis of robustness, robustness against", + "type": "text" + }, + { + "bbox": [ + 379, + 413, + 387, + 425 + ], + "score": 0.86, + "content": "l _ { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 413, + 507, + 425 + ], + "score": 1.0, + "content": "-norm bounded perturbations.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 424, + 506, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 506, + 436 + ], + "score": 1.0, + "content": "While there are ways to extend this, for example to semantic perturbation [28], other axes like", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 435, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 506, + 447 + ], + "score": 1.0, + "content": "robustness to changing environment conditions are not addressed by our method. We want to", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 445, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 505, + 459 + ], + "score": 1.0, + "content": "highlight common terms used in this field like certified defense and robustness may sound very", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 455, + 506, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 506, + 470 + ], + "score": 1.0, + "content": "convincing to a non-expert, but insufficient understanding of the limits of current robust training", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 467, + 468, + 480 + ], + "spans": [ + { + "bbox": [ + 105, + 467, + 468, + 480 + ], + "score": 1.0, + "content": "methods and overly relying on them presents pressing potential for negative social impact.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27 + }, + { + "type": "title", + "bbox": [ + 108, + 493, + 202, + 506 + ], + "lines": [ + { + "bbox": [ + 105, + 491, + 204, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 491, + 204, + 510 + ], + "score": 1.0, + "content": "Acknowledgement", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 518, + 506, + 562 + ], + "lines": [ + { + "bbox": [ + 105, + 518, + 506, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 506, + 530 + ], + "score": 1.0, + "content": "The authors would like to thank anonymous reviewers for valuable feedback to improve the manuscript.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 529, + 506, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 506, + 542 + ], + "score": 1.0, + "content": "The authors thank MIT-IBM Watson AI lab and the MIT SuperUROP program for support in this", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 540, + 507, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 507, + 552 + ], + "score": 1.0, + "content": "work. T. Oikarinen and T.-W. Weng are supported by National Science Foundation under Grant No.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 550, + 147, + 562 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 147, + 562 + ], + "score": 1.0, + "content": "2107189.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33.5 + }, + { + "type": "title", + "bbox": [ + 107, + 577, + 163, + 590 + ], + "lines": [ + { + "bbox": [ + 106, + 577, + 165, + 592 + ], + "spans": [ + { + "bbox": [ + 106, + 577, + 165, + 592 + ], + "score": 1.0, + "content": "References", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 36 + }, + { + "type": "text", + "bbox": [ + 111, + 598, + 507, + 722 + ], + "lines": [ + { + "bbox": [ + 111, + 598, + 441, + 611 + ], + "spans": [ + { + "bbox": [ + 111, + 598, + 441, + 611 + ], + "score": 1.0, + "content": "[1] A. Krizhevsky, “Learning multiple layers of features from tiny images,” 2009.", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 111, + 612, + 506, + 624 + ], + "spans": [ + { + "bbox": [ + 111, + 612, + 506, + 624 + ], + "score": 1.0, + "content": "[2] S. Lai, L. Xu, K. Liu, and J. Zhao, “Recurrent convolutional neural networks for text classifica-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 127, + 623, + 412, + 636 + ], + "spans": [ + { + "bbox": [ + 127, + 623, + 412, + 636 + ], + "score": 1.0, + "content": "tion,” in Twenty-ninth AAAI conference on artificial intelligence, 2015.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 110, + 637, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 110, + 637, + 506, + 651 + ], + "score": 1.0, + "content": "[3] V. Mnih, K. Kavukcuoglu, D. Silver, A. Graves, I. Antonoglou, D. Wierstra, and M. Riedmiller,", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 127, + 648, + 483, + 662 + ], + "spans": [ + { + "bbox": [ + 127, + 648, + 483, + 662 + ], + "score": 1.0, + "content": "“Playing atari with deep reinforcement learning,” arXiv preprint arXiv:1312.5602, 2013.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 110, + 663, + 507, + 677 + ], + "spans": [ + { + "bbox": [ + 110, + 663, + 507, + 677 + ], + "score": 1.0, + "content": "[4] T. P. Lillicrap, J. J. Hunt, A. Pritzel, N. Heess, T. Erez, Y. Tassa, D. Silver, and D. Wierstra,", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 126, + 674, + 413, + 687 + ], + "spans": [ + { + "bbox": [ + 126, + 674, + 413, + 687 + ], + "score": 1.0, + "content": "“Continuous control with deep reinforcement learning.,” in ICLR 2016.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 110, + 687, + 507, + 703 + ], + "spans": [ + { + "bbox": [ + 110, + 687, + 507, + 703 + ], + "score": 1.0, + "content": "[5] C. Szegedy, W. Zaremba, I. Sutskever, J. Bruna, D. Erhan, I. Goodfellow, and R. Fergus,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 125, + 699, + 507, + 713 + ], + "spans": [ + { + "bbox": [ + 125, + 699, + 507, + 713 + ], + "score": 1.0, + "content": "“Intriguing properties of neural networks,” in 2nd International Conference on Learning Repre-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 127, + 712, + 223, + 722 + ], + "spans": [ + { + "bbox": [ + 127, + 712, + 223, + 722 + ], + "score": 1.0, + "content": "sentations, ICLR 2014.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 41.5 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 311, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "score": 1.0, + "content": "10", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 72, + 204, + 84 + ], + "lines": [ + { + "bbox": [ + 105, + 70, + 206, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 70, + 206, + 86 + ], + "score": 1.0, + "content": "4.4 Evaluating GWC", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 106, + 92, + 505, + 224 + ], + "lines": [ + { + "bbox": [ + 105, + 92, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 105, + 92, + 505, + 105 + ], + "score": 1.0, + "content": "We show empirically that GWC is indeed a good approximation of AWC reward. We compare GWC", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 103, + 505, + 115 + ], + "spans": [ + { + "bbox": [ + 105, + 103, + 505, + 115 + ], + "score": 1.0, + "content": "and action certification rate (ACR) against the Absolute Worst-Case Reward (AWC) on a small", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 115, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 505, + 127 + ], + "score": 1.0, + "content": "scale experiments on reaching the first reward within 80 frames on Freeway due to the exponential", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 125, + 506, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 125, + 408, + 138 + ], + "score": 1.0, + "content": "complexity of AWC. Figure is available in Appendix D. GWC is the ratio of", + "type": "text" + }, + { + "bbox": [ + 408, + 126, + 420, + 136 + ], + "score": 0.84, + "content": "+ 1", + "type": "inline_equation" + }, + { + "bbox": [ + 420, + 125, + 506, + 138 + ], + "score": 1.0, + "content": "rewards as measured", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 137, + 505, + 149 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 393, + 149 + ], + "score": 1.0, + "content": "by GWC, while AWC uses depth first search to compute the percentage of", + "type": "text" + }, + { + "bbox": [ + 394, + 137, + 405, + 146 + ], + "score": 0.85, + "content": "+ 1", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 137, + 505, + 149 + ], + "score": 1.0, + "content": "rewards using Algorithm", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 146, + 506, + 160 + ], + "spans": [ + { + "bbox": [ + 104, + 146, + 348, + 160 + ], + "score": 1.0, + "content": "2 (i.e. where all possible sequences of actions get at least", + "type": "text" + }, + { + "bbox": [ + 349, + 148, + 361, + 158 + ], + "score": 0.81, + "content": "+ 1", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 146, + 506, + 160 + ], + "score": 1.0, + "content": "reward). For the episodes that we", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 158, + 506, + 171 + ], + "spans": [ + { + "bbox": [ + 105, + 158, + 293, + 171 + ], + "score": 1.0, + "content": "evaluated, GWC matched AWC perfectly for", + "type": "text" + }, + { + "bbox": [ + 293, + 158, + 368, + 169 + ], + "score": 0.9, + "content": "\\epsilon \\in \\{ 1 . 0 , 1 . 2 , 1 . 5 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 368, + 158, + 506, + 171 + ], + "score": 1.0, + "content": ". Since AWC is a lower bound of", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 169, + 503, + 181 + ], + "spans": [ + { + "bbox": [ + 106, + 169, + 149, + 181 + ], + "score": 1.0, + "content": "GWC, for", + "type": "text" + }, + { + "bbox": [ + 149, + 169, + 206, + 181 + ], + "score": 0.92, + "content": "\\epsilon \\in \\{ 1 . 3 , 1 . 4 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 206, + 169, + 484, + 181 + ], + "score": 1.0, + "content": "GWC matched AWC on 37/40 episodes, while overestimating on the", + "type": "text" + }, + { + "bbox": [ + 484, + 169, + 503, + 180 + ], + "score": 0.28, + "content": "3 / 4 0", + "type": "inline_equation" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 179, + 506, + 192 + ], + "spans": [ + { + "bbox": [ + 105, + 179, + 506, + 192 + ], + "score": 1.0, + "content": "ACR (as used in [17]) did not show as strong of a correlation with AWC. As evident in Table 1, GWC", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 104, + 190, + 506, + 204 + ], + "spans": [ + { + "bbox": [ + 104, + 190, + 506, + 204 + ], + "score": 1.0, + "content": "is a better indicator for the robust performance than ACR – this is the case for Freeway and Pong", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 201, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 105, + 201, + 505, + 213 + ], + "score": 1.0, + "content": "where SA-DQN has higher action certification rates but RADIAL-DQN has higher GWC and PGD", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 213, + 441, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 213, + 441, + 225 + ], + "score": 1.0, + "content": "rewards. Together these results give faith in GWC being a good evaluation method.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 6.5, + "bbox_fs": [ + 104, + 92, + 506, + 225 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 239, + 282, + 252 + ], + "lines": [ + { + "bbox": [ + 104, + 237, + 283, + 254 + ], + "spans": [ + { + "bbox": [ + 104, + 237, + 283, + 254 + ], + "score": 1.0, + "content": "5 Conclusions and Future works", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 263, + 505, + 362 + ], + "lines": [ + { + "bbox": [ + 105, + 262, + 506, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 506, + 276 + ], + "score": 1.0, + "content": "We have shown that using the proposed RADIAL framework can significantly improve the robustness", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 273, + 506, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 506, + 288 + ], + "score": 1.0, + "content": "of deep RL agents against adversarial perturbations based on robustness verification bounds – our", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 285, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 384, + 298 + ], + "score": 1.0, + "content": "robustly trained agents reach very good performance against even", + "type": "text" + }, + { + "bbox": [ + 384, + 286, + 399, + 296 + ], + "score": 0.85, + "content": "5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 285, + 505, + 298 + ], + "score": 1.0, + "content": "larger perturbations than", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 296, + 506, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 506, + 309 + ], + "score": 1.0, + "content": "previous state of the art, and in the meantime are much more computationally efficient to train.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 307, + 506, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 506, + 321 + ], + "score": 1.0, + "content": "In addition, we have presented a new evaluation method, Greedy Worst-Case Reward, as a good", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 318, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 318, + 505, + 331 + ], + "score": 1.0, + "content": "surrogate of the worst-case reward to evaluate deep RL agent’s performance under adversarial", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 329, + 505, + 342 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 505, + 342 + ], + "score": 1.0, + "content": "input perturbations. Future works include extending our framework to defend against semantic", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 339, + 506, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 506, + 353 + ], + "score": 1.0, + "content": "perturbations such as contrast and brightness changes, which are more realistic on the vision-based", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 351, + 322, + 363 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 322, + 363 + ], + "score": 1.0, + "content": "RL agents (e.g. self-driving car, vision-based robots).", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 262, + 506, + 363 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 377, + 339, + 390 + ], + "lines": [ + { + "bbox": [ + 104, + 375, + 341, + 393 + ], + "spans": [ + { + "bbox": [ + 104, + 375, + 341, + 393 + ], + "score": 1.0, + "content": "6 Limitations and Potential negative impact", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 402, + 505, + 478 + ], + "lines": [ + { + "bbox": [ + 105, + 402, + 506, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 506, + 415 + ], + "score": 1.0, + "content": "An important limitation of our work and one that may cause negative impact in the future is that our", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 413, + 507, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 379, + 425 + ], + "score": 1.0, + "content": "work addresses only a specific axis of robustness, robustness against", + "type": "text" + }, + { + "bbox": [ + 379, + 413, + 387, + 425 + ], + "score": 0.86, + "content": "l _ { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 413, + 507, + 425 + ], + "score": 1.0, + "content": "-norm bounded perturbations.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 424, + 506, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 506, + 436 + ], + "score": 1.0, + "content": "While there are ways to extend this, for example to semantic perturbation [28], other axes like", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 435, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 506, + 447 + ], + "score": 1.0, + "content": "robustness to changing environment conditions are not addressed by our method. We want to", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 445, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 505, + 459 + ], + "score": 1.0, + "content": "highlight common terms used in this field like certified defense and robustness may sound very", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 455, + 506, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 506, + 470 + ], + "score": 1.0, + "content": "convincing to a non-expert, but insufficient understanding of the limits of current robust training", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 467, + 468, + 480 + ], + "spans": [ + { + "bbox": [ + 105, + 467, + 468, + 480 + ], + "score": 1.0, + "content": "methods and overly relying on them presents pressing potential for negative social impact.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 402, + 507, + 480 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 493, + 202, + 506 + ], + "lines": [ + { + "bbox": [ + 105, + 491, + 204, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 491, + 204, + 510 + ], + "score": 1.0, + "content": "Acknowledgement", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 518, + 506, + 562 + ], + "lines": [ + { + "bbox": [ + 105, + 518, + 506, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 506, + 530 + ], + "score": 1.0, + "content": "The authors would like to thank anonymous reviewers for valuable feedback to improve the manuscript.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 529, + 506, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 506, + 542 + ], + "score": 1.0, + "content": "The authors thank MIT-IBM Watson AI lab and the MIT SuperUROP program for support in this", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 540, + 507, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 507, + 552 + ], + "score": 1.0, + "content": "work. T. Oikarinen and T.-W. Weng are supported by National Science Foundation under Grant No.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 550, + 147, + 562 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 147, + 562 + ], + "score": 1.0, + "content": "2107189.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 518, + 507, + 562 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 577, + 163, + 590 + ], + "lines": [ + { + "bbox": [ + 106, + 577, + 165, + 592 + ], + "spans": [ + { + "bbox": [ + 106, + 577, + 165, + 592 + ], + "score": 1.0, + "content": "References", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 36 + }, + { + "type": "list", + "bbox": [ + 111, + 598, + 507, + 722 + ], + "lines": [ + { + "bbox": [ + 111, + 598, + 441, + 611 + ], + "spans": [ + { + "bbox": [ + 111, + 598, + 441, + 611 + ], + "score": 1.0, + "content": "[1] A. Krizhevsky, “Learning multiple layers of features from tiny images,” 2009.", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 111, + 612, + 506, + 624 + ], + "spans": [ + { + "bbox": [ + 111, + 612, + 506, + 624 + ], + "score": 1.0, + "content": "[2] S. Lai, L. Xu, K. Liu, and J. Zhao, “Recurrent convolutional neural networks for text classifica-", + "type": "text" + } + ], + "index": 38, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 623, + 412, + 636 + ], + "spans": [ + { + "bbox": [ + 127, + 623, + 412, + 636 + ], + "score": 1.0, + "content": "tion,” in Twenty-ninth AAAI conference on artificial intelligence, 2015.", + "type": "text" + } + ], + "index": 39, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 637, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 110, + 637, + 506, + 651 + ], + "score": 1.0, + "content": "[3] V. Mnih, K. Kavukcuoglu, D. Silver, A. Graves, I. Antonoglou, D. Wierstra, and M. Riedmiller,", + "type": "text" + } + ], + "index": 40, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 648, + 483, + 662 + ], + "spans": [ + { + "bbox": [ + 127, + 648, + 483, + 662 + ], + "score": 1.0, + "content": "“Playing atari with deep reinforcement learning,” arXiv preprint arXiv:1312.5602, 2013.", + "type": "text" + } + ], + "index": 41, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 663, + 507, + 677 + ], + "spans": [ + { + "bbox": [ + 110, + 663, + 507, + 677 + ], + "score": 1.0, + "content": "[4] T. P. Lillicrap, J. J. Hunt, A. Pritzel, N. Heess, T. Erez, Y. Tassa, D. Silver, and D. Wierstra,", + "type": "text" + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 674, + 413, + 687 + ], + "spans": [ + { + "bbox": [ + 126, + 674, + 413, + 687 + ], + "score": 1.0, + "content": "“Continuous control with deep reinforcement learning.,” in ICLR 2016.", + "type": "text" + } + ], + "index": 43, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 687, + 507, + 703 + ], + "spans": [ + { + "bbox": [ + 110, + 687, + 507, + 703 + ], + "score": 1.0, + "content": "[5] C. Szegedy, W. Zaremba, I. Sutskever, J. Bruna, D. Erhan, I. Goodfellow, and R. Fergus,", + "type": "text" + } + ], + "index": 44, + "is_list_start_line": true + }, + { + "bbox": [ + 125, + 699, + 507, + 713 + ], + "spans": [ + { + "bbox": [ + 125, + 699, + 507, + 713 + ], + "score": 1.0, + "content": "“Intriguing properties of neural networks,” in 2nd International Conference on Learning Repre-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 127, + 712, + 223, + 722 + ], + "spans": [ + { + "bbox": [ + 127, + 712, + 223, + 722 + ], + "score": 1.0, + "content": "sentations, ICLR 2014.", + "type": "text" + } + ], + "index": 46, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 72, + 506, + 86 + ], + "spans": [ + { + "bbox": [ + 110, + 72, + 506, + 86 + ], + "score": 1.0, + "content": "[6] S. Huang, N. Papernot, I. Goodfellow, Y. Duan, and P. Abbeel, “Adversarial attacks on neural", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 83, + 365, + 96 + ], + "spans": [ + { + "bbox": [ + 126, + 83, + 365, + 96 + ], + "score": 1.0, + "content": "network policies,” arXiv preprint arXiv:1702.02284, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 1, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 98, + 506, + 112 + ], + "spans": [ + { + "bbox": [ + 110, + 98, + 506, + 112 + ], + "score": 1.0, + "content": "[7] Y.-C. Lin, Z.-W. Hong, Y.-H. Liao, M.-L. Shih, M.-Y. Liu, and M. Sun, “Tactics of adversarial", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 110, + 506, + 123 + ], + "spans": [ + { + "bbox": [ + 127, + 110, + 506, + 123 + ], + "score": 1.0, + "content": "attack on deep reinforcement learning agents,” in Proceedings of the 26th International Joint", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 126, + 119, + 369, + 134 + ], + "spans": [ + { + "bbox": [ + 126, + 119, + 369, + 134 + ], + "score": 1.0, + "content": "Conference on Artificial Intelligence, pp. 3756–3762, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 135, + 506, + 149 + ], + "spans": [ + { + "bbox": [ + 110, + 135, + 506, + 149 + ], + "score": 1.0, + "content": "[8] T.-W. Weng, K. D. Dvijotham, J. Uesato, K. Xiao, S. Gowal, R. Stanforth, and P. Kohli, “Toward", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 146, + 495, + 160 + ], + "spans": [ + { + "bbox": [ + 126, + 146, + 495, + 160 + ], + "score": 1.0, + "content": "evaluating robustness of deep reinforcement learning with continuous control,” ICLR 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 110, + 160, + 506, + 176 + ], + "spans": [ + { + "bbox": [ + 110, + 160, + 506, + 176 + ], + "score": 1.0, + "content": "[9] F. Tramer, N. Carlini, W. Brendel, and A. Madry, “On adaptive attacks to adversarial example", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 172, + 443, + 186 + ], + "spans": [ + { + "bbox": [ + 126, + 172, + 443, + 186 + ], + "score": 1.0, + "content": "defenses,” Advances in Neural Information Processing Systems, vol. 33, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 186, + 506, + 202 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 506, + 202 + ], + "score": 1.0, + "content": "[10] A. Raghunathan, J. Steinhardt, and P. Liang, “Certified defenses against adversarial examples,”", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 198, + 178, + 212 + ], + "spans": [ + { + "bbox": [ + 127, + 198, + 178, + 212 + ], + "score": 1.0, + "content": "ICLR 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 10, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 213, + 506, + 226 + ], + "spans": [ + { + "bbox": [ + 105, + 213, + 506, + 226 + ], + "score": 1.0, + "content": "[11] J. Z. Kolter and E. Wong, “Provable defenses against adversarial examples via the convex outer", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 224, + 270, + 238 + ], + "spans": [ + { + "bbox": [ + 126, + 224, + 270, + 238 + ], + "score": 1.0, + "content": "adversarial polytope,” ICML 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 12, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 239, + 507, + 253 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 507, + 253 + ], + "score": 1.0, + "content": "[12] L. Weng, H. Zhang, H. Chen, Z. Song, C.-J. Hsieh, L. Daniel, D. Boning, and I. Dhillon,", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 125, + 248, + 506, + 265 + ], + "spans": [ + { + "bbox": [ + 125, + 248, + 506, + 265 + ], + "score": 1.0, + "content": "“Towards fast computation of certified robustness for relu networks,” in International Conference", + "type": "text", + "cross_page": true + } + ], + "index": 14 + }, + { + "bbox": [ + 127, + 261, + 341, + 275 + ], + "spans": [ + { + "bbox": [ + 127, + 261, + 341, + 275 + ], + "score": 1.0, + "content": "on Machine Learning, pp. 5276–5285, PMLR, 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 15, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 275, + 506, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 506, + 289 + ], + "score": 1.0, + "content": "[13] G. Singh, T. Gehr, M. Mirman, M. Püschel, and M. Vechev, “Fast and effective robustness", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 288, + 257, + 299 + ], + "spans": [ + { + "bbox": [ + 127, + 288, + 257, + 299 + ], + "score": 1.0, + "content": "certification,” in NeurIPS 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 302, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 506, + 316 + ], + "score": 1.0, + "content": "[14] S. Gowal, K. Dvijotham, R. Stanforth, R. Bunel, C. Qin, J. Uesato, R. Arandjelovic, T. Mann,", + "type": "text", + "cross_page": true + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 312, + 506, + 326 + ], + "spans": [ + { + "bbox": [ + 126, + 312, + 506, + 326 + ], + "score": 1.0, + "content": "and P. Kohli, “On the effectiveness of interval bound propagation for training verifiably robust", + "type": "text", + "cross_page": true + } + ], + "index": 19 + }, + { + "bbox": [ + 126, + 324, + 327, + 337 + ], + "spans": [ + { + "bbox": [ + 126, + 324, + 327, + 337 + ], + "score": 1.0, + "content": "models,” arXiv preprint arXiv:1810.12715, 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 20, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 338, + 506, + 352 + ], + "spans": [ + { + "bbox": [ + 105, + 338, + 506, + 352 + ], + "score": 1.0, + "content": "[15] V. Mnih, A. P. Badia, M. Mirza, A. Graves, T. Lillicrap, T. Harley, D. Silver, and K. Kavukcuoglu,", + "type": "text", + "cross_page": true + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 349, + 506, + 363 + ], + "spans": [ + { + "bbox": [ + 127, + 349, + 506, + 363 + ], + "score": 1.0, + "content": "“Asynchronous methods for deep reinforcement learning,” in International conference on ma-", + "type": "text", + "cross_page": true + } + ], + "index": 22 + }, + { + "bbox": [ + 125, + 359, + 314, + 375 + ], + "spans": [ + { + "bbox": [ + 125, + 359, + 314, + 375 + ], + "score": 1.0, + "content": "chine learning, pp. 1928–1937, PMLR, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 23, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 374, + 506, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 506, + 389 + ], + "score": 1.0, + "content": "[16] J. Schulman, F. Wolski, P. Dhariwal, A. Radford, and O. Klimov, “Proximal policy optimization", + "type": "text", + "cross_page": true + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 386, + 342, + 400 + ], + "spans": [ + { + "bbox": [ + 126, + 386, + 342, + 400 + ], + "score": 1.0, + "content": "algorithms,” arXiv preprint arXiv:1707.06347, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 399, + 506, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 506, + 416 + ], + "score": 1.0, + "content": "[17] H. Zhang, H. Chen, C. Xiao, B. Li, M. Liu, D. S. Boning, and C.-J. Hsieh, “Robust deep", + "type": "text", + "cross_page": true + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 412, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 126, + 412, + 506, + 426 + ], + "score": 1.0, + "content": "reinforcement learning against adversarial perturbations on state observations,” in NeurIPS", + "type": "text", + "cross_page": true + } + ], + "index": 27 + }, + { + "bbox": [ + 126, + 424, + 154, + 436 + ], + "spans": [ + { + "bbox": [ + 126, + 424, + 154, + 436 + ], + "score": 1.0, + "content": "2020.", + "type": "text", + "cross_page": true + } + ], + "index": 28, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 438, + 506, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 438, + 506, + 452 + ], + "score": 1.0, + "content": "[18] M. Fischer, M. Mirman, S. Stalder, and M. Vechev, “Online robustness training for deep", + "type": "text", + "cross_page": true + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 449, + 389, + 463 + ], + "spans": [ + { + "bbox": [ + 126, + 449, + 389, + 463 + ], + "score": 1.0, + "content": "reinforcement learning,” arXiv preprint arXiv:1911.00887, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 462, + 508, + 479 + ], + "spans": [ + { + "bbox": [ + 104, + 462, + 508, + 479 + ], + "score": 1.0, + "content": "[19] I. J. Goodfellow, J. Shlens, and C. Szegedy, “Explaining and harnessing adversarial examples,”", + "type": "text", + "cross_page": true + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 475, + 178, + 488 + ], + "spans": [ + { + "bbox": [ + 126, + 475, + 178, + 488 + ], + "score": 1.0, + "content": "ICLR 2015.", + "type": "text", + "cross_page": true + } + ], + "index": 32, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 488, + 507, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 507, + 505 + ], + "score": 1.0, + "content": "[20] D. J. Mankowitz, N. Levine, R. Jeong, A. Abdolmaleki, J. T. Springenberg, Y. Shi, J. Kay,", + "type": "text", + "cross_page": true + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 128, + 502, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 128, + 502, + 505, + 513 + ], + "score": 1.0, + "content": "T. Hester, T. Mann, and M. Riedmiller, “Robust reinforcement learning for continuous control", + "type": "text", + "cross_page": true + } + ], + "index": 34 + }, + { + "bbox": [ + 127, + 512, + 507, + 526 + ], + "spans": [ + { + "bbox": [ + 127, + 512, + 507, + 526 + ], + "score": 1.0, + "content": "with model misspecification,” in International Conference on Learning Representations, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 526, + 508, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 508, + 540 + ], + "score": 1.0, + "content": "[21] L. Pinto, J. Davidson, R. Sukthankar, and A. Gupta, “Robust adversarial reinforcement learning,”", + "type": "text", + "cross_page": true + } + ], + "index": 36, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 537, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 126, + 537, + 505, + 551 + ], + "score": 1.0, + "content": "in Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 2817–", + "type": "text", + "cross_page": true + } + ], + "index": 37 + }, + { + "bbox": [ + 127, + 548, + 228, + 562 + ], + "spans": [ + { + "bbox": [ + 127, + 548, + 228, + 562 + ], + "score": 1.0, + "content": "2826, JMLR. org, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 38, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 563, + 506, + 577 + ], + "spans": [ + { + "bbox": [ + 106, + 563, + 506, + 577 + ], + "score": 1.0, + "content": "[22] A. Gleave, M. Dennis, C. Wild, N. Kant, S. Levine, and S. Russell, “Adversarial policies: At-", + "type": "text", + "cross_page": true + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 575, + 507, + 588 + ], + "spans": [ + { + "bbox": [ + 126, + 575, + 507, + 588 + ], + "score": 1.0, + "content": "tacking deep reinforcement learning,” in International Conference on Learning Representations,", + "type": "text", + "cross_page": true + } + ], + "index": 40 + }, + { + "bbox": [ + 126, + 585, + 154, + 599 + ], + "spans": [ + { + "bbox": [ + 126, + 585, + 154, + 599 + ], + "score": 1.0, + "content": "2020.", + "type": "text", + "cross_page": true + } + ], + "index": 41, + "is_list_end_line": true + }, + { + "bbox": [ + 107, + 601, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 107, + 601, + 506, + 613 + ], + "score": 1.0, + "content": "[23] I. Ilahi, M. Usama, J. Qadir, M. U. Janjua, A. Al-Fuqaha, D. T. Huang, and D. Niyato, “Chal-", + "type": "text", + "cross_page": true + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 611, + 506, + 625 + ], + "spans": [ + { + "bbox": [ + 127, + 611, + 506, + 625 + ], + "score": 1.0, + "content": "lenges and countermeasures for adversarial attacks on deep reinforcement learning,” IEEE", + "type": "text", + "cross_page": true + } + ], + "index": 43 + }, + { + "bbox": [ + 128, + 623, + 308, + 635 + ], + "spans": [ + { + "bbox": [ + 128, + 623, + 308, + 635 + ], + "score": 1.0, + "content": "Transactions on Artificial Intelligence, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 44, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 637, + 506, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 506, + 650 + ], + "score": 1.0, + "content": "[24] Y.-S. Wang, T.-W. Weng, and L. Daniel, “Verification of neural network control policy under", + "type": "text", + "cross_page": true + } + ], + "index": 45, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 647, + 434, + 662 + ], + "spans": [ + { + "bbox": [ + 126, + 647, + 434, + 662 + ], + "score": 1.0, + "content": "persistent adversarial perturbation,” arXiv preprint arXiv:1908.06353, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 46, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 662, + 506, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 662, + 506, + 677 + ], + "score": 1.0, + "content": "[25] J. Kos and D. Song, “Delving into adversarial attacks on deep policies,” arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 47, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 673, + 232, + 687 + ], + "spans": [ + { + "bbox": [ + 127, + 673, + 232, + 687 + ], + "score": 1.0, + "content": "arXiv:1705.06452, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 48, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 689, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 506, + 702 + ], + "score": 1.0, + "content": "[26] A. Pattanaik, Z. Tang, S. Liu, G. Bommannan, and G. Chowdhary, “Robust deep reinforcement", + "type": "text", + "cross_page": true + } + ], + "index": 49, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 698, + 507, + 715 + ], + "spans": [ + { + "bbox": [ + 126, + 698, + 507, + 715 + ], + "score": 1.0, + "content": "learning with adversarial attacks,” in Proceedings of the 17th International Conference on", + "type": "text", + "cross_page": true + } + ], + "index": 50 + }, + { + "bbox": [ + 125, + 710, + 401, + 726 + ], + "spans": [ + { + "bbox": [ + 125, + 710, + 401, + 726 + ], + "score": 1.0, + "content": "Autonomous Agents and MultiAgent Systems, pp. 2040–2042, 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 51, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 73, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 106, + 73, + 505, + 85 + ], + "score": 1.0, + "content": "[27] B. Lütjens, M. Everett, and J. P. How, “Certified adversarial robustness for deep reinforcement", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 83, + 429, + 96 + ], + "spans": [ + { + "bbox": [ + 127, + 83, + 429, + 96 + ], + "score": 1.0, + "content": "learning,” in Conference on Robot Learning, pp. 1328–1337, PMLR, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 1, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 98, + 505, + 111 + ], + "spans": [ + { + "bbox": [ + 106, + 98, + 505, + 111 + ], + "score": 1.0, + "content": "[28] J. Mohapatra, P.-Y. Chen, S. Liu, L. Daniel, et al., “Towards verifying robustness of neural", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 110, + 348, + 121 + ], + "spans": [ + { + "bbox": [ + 127, + 110, + 348, + 121 + ], + "score": 1.0, + "content": "networks against semantic perturbations,” CVPR 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 124, + 505, + 137 + ], + "spans": [ + { + "bbox": [ + 106, + 124, + 505, + 137 + ], + "score": 1.0, + "content": "[29] Z. Wang, T. Schaul, M. Hessel, H. Hasselt, M. Lanctot, and N. Freitas, “Dueling network", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 135, + 506, + 148 + ], + "spans": [ + { + "bbox": [ + 127, + 135, + 506, + 148 + ], + "score": 1.0, + "content": "architectures for deep reinforcement learning,” in International conference on machine learning,", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 126, + 146, + 250, + 158 + ], + "spans": [ + { + "bbox": [ + 126, + 146, + 250, + 158 + ], + "score": 1.0, + "content": "pp. 1995–2003, PMLR, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 6, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 160, + 506, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 160, + 506, + 174 + ], + "score": 1.0, + "content": "[30] H. Van Hasselt, A. Guez, and D. Silver, “Deep reinforcement learning with double q-learning,”", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 128, + 173, + 442, + 184 + ], + "spans": [ + { + "bbox": [ + 128, + 173, + 442, + 184 + ], + "score": 1.0, + "content": "in Proceedings of the AAAI conference on artificial intelligence, vol. 30, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 187, + 506, + 199 + ], + "spans": [ + { + "bbox": [ + 106, + 187, + 506, + 199 + ], + "score": 1.0, + "content": "[31] S. Wang, K. Pei, J. Whitehouse, J. Yang, and S. Jana, “Efficient formal safety analysis of neural", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 198, + 488, + 211 + ], + "spans": [ + { + "bbox": [ + 126, + 198, + 488, + 211 + ], + "score": 1.0, + "content": "networks,” in Advances in Neural Information Processing Systems, pp. 6367–6377, 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 10, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 213, + 506, + 225 + ], + "spans": [ + { + "bbox": [ + 106, + 213, + 506, + 225 + ], + "score": 1.0, + "content": "[32] H. Zhang, T.-W. Weng, P.-Y. Chen, C.-J. Hsieh, and L. Daniel, “Efficient neural network", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 223, + 505, + 236 + ], + "spans": [ + { + "bbox": [ + 127, + 223, + 505, + 236 + ], + "score": 1.0, + "content": "robustness certification with general activation functions,” in Advances in neural information", + "type": "text", + "cross_page": true + } + ], + "index": 12 + }, + { + "bbox": [ + 126, + 235, + 299, + 246 + ], + "spans": [ + { + "bbox": [ + 126, + 235, + 299, + 246 + ], + "score": 1.0, + "content": "processing systems, pp. 4939–4948, 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 249, + 506, + 262 + ], + "spans": [ + { + "bbox": [ + 106, + 249, + 506, + 262 + ], + "score": 1.0, + "content": "[33] A. Boopathy, T.-W. Weng, P.-Y. Chen, S. Liu, and L. Daniel, “Cnn-cert: An efficient frame-", + "type": "text", + "cross_page": true + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 261, + 506, + 273 + ], + "spans": [ + { + "bbox": [ + 127, + 261, + 506, + 273 + ], + "score": 1.0, + "content": "work for certifying robustness of convolutional neural networks,” in Proceedings of the AAAI", + "type": "text", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 128, + 271, + 400, + 284 + ], + "spans": [ + { + "bbox": [ + 128, + 271, + 400, + 284 + ], + "score": 1.0, + "content": "Conference on Artificial Intelligence, vol. 33, pp. 3240–3247, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 286, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 106, + 286, + 506, + 299 + ], + "score": 1.0, + "content": "[34] V. Tjeng, K. Y. Xiao, and R. Tedrake, “Evaluating robustness of neural networks with mixed", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 297, + 480, + 309 + ], + "spans": [ + { + "bbox": [ + 127, + 297, + 480, + 309 + ], + "score": 1.0, + "content": "integer programming,” in International Conference on Learning Representations, 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 18, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 312, + 506, + 324 + ], + "spans": [ + { + "bbox": [ + 106, + 312, + 506, + 324 + ], + "score": 1.0, + "content": "[35] M. G. Bellemare, Y. Naddaf, J. Veness, and M. Bowling, “The arcade learning environment:", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 323, + 506, + 336 + ], + "spans": [ + { + "bbox": [ + 127, + 323, + 506, + 336 + ], + "score": 1.0, + "content": "An evaluation platform for general agents,” Journal of Artificial Intelligence Research, vol. 47,", + "type": "text", + "cross_page": true + } + ], + "index": 20 + }, + { + "bbox": [ + 126, + 334, + 219, + 345 + ], + "spans": [ + { + "bbox": [ + 126, + 334, + 219, + 345 + ], + "score": 1.0, + "content": "p. 253–279, Jun 2013.", + "type": "text", + "cross_page": true + } + ], + "index": 21, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 349, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 106, + 349, + 506, + 361 + ], + "score": 1.0, + "content": "[36] K. Cobbe, C. Hesse, J. Hilton, and J. Schulman, “Leveraging procedural generation to bench-", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 360, + 506, + 372 + ], + "spans": [ + { + "bbox": [ + 127, + 360, + 506, + 372 + ], + "score": 1.0, + "content": "mark reinforcement learning,” in International conference on machine learning, pp. 2048–2056,", + "type": "text", + "cross_page": true + } + ], + "index": 23 + }, + { + "bbox": [ + 128, + 371, + 185, + 381 + ], + "spans": [ + { + "bbox": [ + 128, + 371, + 185, + 381 + ], + "score": 1.0, + "content": "PMLR, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 24, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 385, + 506, + 398 + ], + "spans": [ + { + "bbox": [ + 106, + 385, + 506, + 398 + ], + "score": 1.0, + "content": "[37] E. Todorov, T. Erez, and Y. Tassa, “Mujoco: A physics engine for model-based control,” in 2012", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 397, + 504, + 409 + ], + "spans": [ + { + "bbox": [ + 127, + 397, + 504, + 409 + ], + "score": 1.0, + "content": "IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 5026–5033, 2012.", + "type": "text", + "cross_page": true + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 412, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 106, + 412, + 505, + 423 + ], + "score": 1.0, + "content": "[38] H. Zhang, H. Chen, C. Xiao, S. Gowal, R. Stanforth, B. Li, D. Boning, and C.-J. Hsieh, “Towards", + "type": "text", + "cross_page": true + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 422, + 505, + 435 + ], + "spans": [ + { + "bbox": [ + 127, + 422, + 505, + 435 + ], + "score": 1.0, + "content": "stable and efficient training of verifiably robust neural networks,” in International Conference", + "type": "text", + "cross_page": true + } + ], + "index": 28 + }, + { + "bbox": [ + 127, + 433, + 273, + 446 + ], + "spans": [ + { + "bbox": [ + 127, + 433, + 273, + 446 + ], + "score": 1.0, + "content": "on Learning Representations, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 29, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 449, + 475, + 460 + ], + "spans": [ + { + "bbox": [ + 106, + 449, + 475, + 460 + ], + "score": 1.0, + "content": "[39] D. P. Kingma and J. Ba, “Adam: A method for stochastic optimization,” in ICLR 2015.", + "type": "text", + "cross_page": true + } + ], + "index": 30, + "is_list_start_line": true, + "is_list_end_line": true + } + ], + "index": 41.5, + "bbox_fs": [ + 110, + 598, + 507, + 722 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 60, + 507, + 725 + ], + "lines": [ + { + "bbox": [ + 110, + 72, + 506, + 86 + ], + "spans": [ + { + "bbox": [ + 110, + 72, + 506, + 86 + ], + "score": 1.0, + "content": "[6] S. Huang, N. Papernot, I. Goodfellow, Y. Duan, and P. Abbeel, “Adversarial attacks on neural", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 126, + 83, + 365, + 96 + ], + "spans": [ + { + "bbox": [ + 126, + 83, + 365, + 96 + ], + "score": 1.0, + "content": "network policies,” arXiv preprint arXiv:1702.02284, 2017.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 110, + 98, + 506, + 112 + ], + "spans": [ + { + "bbox": [ + 110, + 98, + 506, + 112 + ], + "score": 1.0, + "content": "[7] Y.-C. Lin, Z.-W. Hong, Y.-H. Liao, M.-L. Shih, M.-Y. Liu, and M. Sun, “Tactics of adversarial", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 127, + 110, + 506, + 123 + ], + "spans": [ + { + "bbox": [ + 127, + 110, + 506, + 123 + ], + "score": 1.0, + "content": "attack on deep reinforcement learning agents,” in Proceedings of the 26th International Joint", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 126, + 119, + 369, + 134 + ], + "spans": [ + { + "bbox": [ + 126, + 119, + 369, + 134 + ], + "score": 1.0, + "content": "Conference on Artificial Intelligence, pp. 3756–3762, 2017.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 110, + 135, + 506, + 149 + ], + "spans": [ + { + "bbox": [ + 110, + 135, + 506, + 149 + ], + "score": 1.0, + "content": "[8] T.-W. Weng, K. D. Dvijotham, J. Uesato, K. Xiao, S. Gowal, R. Stanforth, and P. Kohli, “Toward", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 126, + 146, + 495, + 160 + ], + "spans": [ + { + "bbox": [ + 126, + 146, + 495, + 160 + ], + "score": 1.0, + "content": "evaluating robustness of deep reinforcement learning with continuous control,” ICLR 2020.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 110, + 160, + 506, + 176 + ], + "spans": [ + { + "bbox": [ + 110, + 160, + 506, + 176 + ], + "score": 1.0, + "content": "[9] F. Tramer, N. Carlini, W. Brendel, and A. Madry, “On adaptive attacks to adversarial example", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 126, + 172, + 443, + 186 + ], + "spans": [ + { + "bbox": [ + 126, + 172, + 443, + 186 + ], + "score": 1.0, + "content": "defenses,” Advances in Neural Information Processing Systems, vol. 33, 2020.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 186, + 506, + 202 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 506, + 202 + ], + "score": 1.0, + "content": "[10] A. Raghunathan, J. Steinhardt, and P. Liang, “Certified defenses against adversarial examples,”", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 127, + 198, + 178, + 212 + ], + "spans": [ + { + "bbox": [ + 127, + 198, + 178, + 212 + ], + "score": 1.0, + "content": "ICLR 2018.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 213, + 506, + 226 + ], + "spans": [ + { + "bbox": [ + 105, + 213, + 506, + 226 + ], + "score": 1.0, + "content": "[11] J. Z. Kolter and E. Wong, “Provable defenses against adversarial examples via the convex outer", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 126, + 224, + 270, + 238 + ], + "spans": [ + { + "bbox": [ + 126, + 224, + 270, + 238 + ], + "score": 1.0, + "content": "adversarial polytope,” ICML 2018.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 239, + 507, + 253 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 507, + 253 + ], + "score": 1.0, + "content": "[12] L. Weng, H. Zhang, H. Chen, Z. Song, C.-J. Hsieh, L. Daniel, D. Boning, and I. Dhillon,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 125, + 248, + 506, + 265 + ], + "spans": [ + { + "bbox": [ + 125, + 248, + 506, + 265 + ], + "score": 1.0, + "content": "“Towards fast computation of certified robustness for relu networks,” in International Conference", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 127, + 261, + 341, + 275 + ], + "spans": [ + { + "bbox": [ + 127, + 261, + 341, + 275 + ], + "score": 1.0, + "content": "on Machine Learning, pp. 5276–5285, PMLR, 2018.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 275, + 506, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 506, + 289 + ], + "score": 1.0, + "content": "[13] G. Singh, T. Gehr, M. Mirman, M. Püschel, and M. Vechev, “Fast and effective robustness", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 127, + 288, + 257, + 299 + ], + "spans": [ + { + "bbox": [ + 127, + 288, + 257, + 299 + ], + "score": 1.0, + "content": "certification,” in NeurIPS 2018.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 302, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 506, + 316 + ], + "score": 1.0, + "content": "[14] S. Gowal, K. Dvijotham, R. Stanforth, R. Bunel, C. Qin, J. Uesato, R. Arandjelovic, T. Mann,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 126, + 312, + 506, + 326 + ], + "spans": [ + { + "bbox": [ + 126, + 312, + 506, + 326 + ], + "score": 1.0, + "content": "and P. Kohli, “On the effectiveness of interval bound propagation for training verifiably robust", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 126, + 324, + 327, + 337 + ], + "spans": [ + { + "bbox": [ + 126, + 324, + 327, + 337 + ], + "score": 1.0, + "content": "models,” arXiv preprint arXiv:1810.12715, 2018.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 338, + 506, + 352 + ], + "spans": [ + { + "bbox": [ + 105, + 338, + 506, + 352 + ], + "score": 1.0, + "content": "[15] V. Mnih, A. P. Badia, M. Mirza, A. Graves, T. Lillicrap, T. Harley, D. Silver, and K. Kavukcuoglu,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 127, + 349, + 506, + 363 + ], + "spans": [ + { + "bbox": [ + 127, + 349, + 506, + 363 + ], + "score": 1.0, + "content": "“Asynchronous methods for deep reinforcement learning,” in International conference on ma-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 125, + 359, + 314, + 375 + ], + "spans": [ + { + "bbox": [ + 125, + 359, + 314, + 375 + ], + "score": 1.0, + "content": "chine learning, pp. 1928–1937, PMLR, 2016.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 374, + 506, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 506, + 389 + ], + "score": 1.0, + "content": "[16] J. Schulman, F. Wolski, P. Dhariwal, A. Radford, and O. Klimov, “Proximal policy optimization", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 126, + 386, + 342, + 400 + ], + "spans": [ + { + "bbox": [ + 126, + 386, + 342, + 400 + ], + "score": 1.0, + "content": "algorithms,” arXiv preprint arXiv:1707.06347, 2017.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 399, + 506, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 506, + 416 + ], + "score": 1.0, + "content": "[17] H. Zhang, H. Chen, C. Xiao, B. Li, M. Liu, D. S. Boning, and C.-J. Hsieh, “Robust deep", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 126, + 412, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 126, + 412, + 506, + 426 + ], + "score": 1.0, + "content": "reinforcement learning against adversarial perturbations on state observations,” in NeurIPS", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 126, + 424, + 154, + 436 + ], + "spans": [ + { + "bbox": [ + 126, + 424, + 154, + 436 + ], + "score": 1.0, + "content": "2020.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 438, + 506, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 438, + 506, + 452 + ], + "score": 1.0, + "content": "[18] M. Fischer, M. Mirman, S. Stalder, and M. Vechev, “Online robustness training for deep", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 126, + 449, + 389, + 463 + ], + "spans": [ + { + "bbox": [ + 126, + 449, + 389, + 463 + ], + "score": 1.0, + "content": "reinforcement learning,” arXiv preprint arXiv:1911.00887, 2019.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 462, + 508, + 479 + ], + "spans": [ + { + "bbox": [ + 104, + 462, + 508, + 479 + ], + "score": 1.0, + "content": "[19] I. J. Goodfellow, J. Shlens, and C. Szegedy, “Explaining and harnessing adversarial examples,”", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 126, + 475, + 178, + 488 + ], + "spans": [ + { + "bbox": [ + 126, + 475, + 178, + 488 + ], + "score": 1.0, + "content": "ICLR 2015.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 488, + 507, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 507, + 505 + ], + "score": 1.0, + "content": "[20] D. J. Mankowitz, N. Levine, R. Jeong, A. Abdolmaleki, J. T. Springenberg, Y. Shi, J. Kay,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 128, + 502, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 128, + 502, + 505, + 513 + ], + "score": 1.0, + "content": "T. Hester, T. Mann, and M. Riedmiller, “Robust reinforcement learning for continuous control", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 127, + 512, + 507, + 526 + ], + "spans": [ + { + "bbox": [ + 127, + 512, + 507, + 526 + ], + "score": 1.0, + "content": "with model misspecification,” in International Conference on Learning Representations, 2020.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 526, + 508, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 508, + 540 + ], + "score": 1.0, + "content": "[21] L. Pinto, J. Davidson, R. Sukthankar, and A. Gupta, “Robust adversarial reinforcement learning,”", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 126, + 537, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 126, + 537, + 505, + 551 + ], + "score": 1.0, + "content": "in Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 2817–", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 127, + 548, + 228, + 562 + ], + "spans": [ + { + "bbox": [ + 127, + 548, + 228, + 562 + ], + "score": 1.0, + "content": "2826, JMLR. org, 2017.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 563, + 506, + 577 + ], + "spans": [ + { + "bbox": [ + 106, + 563, + 506, + 577 + ], + "score": 1.0, + "content": "[22] A. Gleave, M. Dennis, C. Wild, N. Kant, S. Levine, and S. Russell, “Adversarial policies: At-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 126, + 575, + 507, + 588 + ], + "spans": [ + { + "bbox": [ + 126, + 575, + 507, + 588 + ], + "score": 1.0, + "content": "tacking deep reinforcement learning,” in International Conference on Learning Representations,", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 126, + 585, + 154, + 599 + ], + "spans": [ + { + "bbox": [ + 126, + 585, + 154, + 599 + ], + "score": 1.0, + "content": "2020.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 107, + 601, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 107, + 601, + 506, + 613 + ], + "score": 1.0, + "content": "[23] I. Ilahi, M. Usama, J. Qadir, M. U. Janjua, A. Al-Fuqaha, D. T. Huang, and D. Niyato, “Chal-", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 127, + 611, + 506, + 625 + ], + "spans": [ + { + "bbox": [ + 127, + 611, + 506, + 625 + ], + "score": 1.0, + "content": "lenges and countermeasures for adversarial attacks on deep reinforcement learning,” IEEE", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 128, + 623, + 308, + 635 + ], + "spans": [ + { + "bbox": [ + 128, + 623, + 308, + 635 + ], + "score": 1.0, + "content": "Transactions on Artificial Intelligence, 2021.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 637, + 506, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 506, + 650 + ], + "score": 1.0, + "content": "[24] Y.-S. Wang, T.-W. Weng, and L. Daniel, “Verification of neural network control policy under", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 126, + 647, + 434, + 662 + ], + "spans": [ + { + "bbox": [ + 126, + 647, + 434, + 662 + ], + "score": 1.0, + "content": "persistent adversarial perturbation,” arXiv preprint arXiv:1908.06353, 2019.", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 662, + 506, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 662, + 506, + 677 + ], + "score": 1.0, + "content": "[25] J. Kos and D. Song, “Delving into adversarial attacks on deep policies,” arXiv preprint", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 127, + 673, + 232, + 687 + ], + "spans": [ + { + "bbox": [ + 127, + 673, + 232, + 687 + ], + "score": 1.0, + "content": "arXiv:1705.06452, 2017.", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 689, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 506, + 702 + ], + "score": 1.0, + "content": "[26] A. Pattanaik, Z. Tang, S. Liu, G. Bommannan, and G. Chowdhary, “Robust deep reinforcement", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 126, + 698, + 507, + 715 + ], + "spans": [ + { + "bbox": [ + 126, + 698, + 507, + 715 + ], + "score": 1.0, + "content": "learning with adversarial attacks,” in Proceedings of the 17th International Conference on", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 125, + 710, + 401, + 726 + ], + "spans": [ + { + "bbox": [ + 125, + 710, + 401, + 726 + ], + "score": 1.0, + "content": "Autonomous Agents and MultiAgent Systems, pp. 2040–2042, 2018.", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 25.5 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 311, + 751 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 312, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 312, + 754 + ], + "score": 1.0, + "content": "11", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 105, + 60, + 507, + 725 + ], + "lines": [], + "index": 25.5, + "bbox_fs": [ + 104, + 72, + 508, + 726 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 69, + 507, + 465 + ], + "lines": [ + { + "bbox": [ + 106, + 73, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 106, + 73, + 505, + 85 + ], + "score": 1.0, + "content": "[27] B. Lütjens, M. Everett, and J. P. How, “Certified adversarial robustness for deep reinforcement", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 127, + 83, + 429, + 96 + ], + "spans": [ + { + "bbox": [ + 127, + 83, + 429, + 96 + ], + "score": 1.0, + "content": "learning,” in Conference on Robot Learning, pp. 1328–1337, PMLR, 2020.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 98, + 505, + 111 + ], + "spans": [ + { + "bbox": [ + 106, + 98, + 505, + 111 + ], + "score": 1.0, + "content": "[28] J. Mohapatra, P.-Y. Chen, S. Liu, L. Daniel, et al., “Towards verifying robustness of neural", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 127, + 110, + 348, + 121 + ], + "spans": [ + { + "bbox": [ + 127, + 110, + 348, + 121 + ], + "score": 1.0, + "content": "networks against semantic perturbations,” CVPR 2020.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 124, + 505, + 137 + ], + "spans": [ + { + "bbox": [ + 106, + 124, + 505, + 137 + ], + "score": 1.0, + "content": "[29] Z. Wang, T. Schaul, M. Hessel, H. Hasselt, M. Lanctot, and N. Freitas, “Dueling network", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 127, + 135, + 506, + 148 + ], + "spans": [ + { + "bbox": [ + 127, + 135, + 506, + 148 + ], + "score": 1.0, + "content": "architectures for deep reinforcement learning,” in International conference on machine learning,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 126, + 146, + 250, + 158 + ], + "spans": [ + { + "bbox": [ + 126, + 146, + 250, + 158 + ], + "score": 1.0, + "content": "pp. 1995–2003, PMLR, 2016.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 160, + 506, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 160, + 506, + 174 + ], + "score": 1.0, + "content": "[30] H. Van Hasselt, A. Guez, and D. Silver, “Deep reinforcement learning with double q-learning,”", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 128, + 173, + 442, + 184 + ], + "spans": [ + { + "bbox": [ + 128, + 173, + 442, + 184 + ], + "score": 1.0, + "content": "in Proceedings of the AAAI conference on artificial intelligence, vol. 30, 2016.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 187, + 506, + 199 + ], + "spans": [ + { + "bbox": [ + 106, + 187, + 506, + 199 + ], + "score": 1.0, + "content": "[31] S. Wang, K. Pei, J. Whitehouse, J. Yang, and S. Jana, “Efficient formal safety analysis of neural", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 126, + 198, + 488, + 211 + ], + "spans": [ + { + "bbox": [ + 126, + 198, + 488, + 211 + ], + "score": 1.0, + "content": "networks,” in Advances in Neural Information Processing Systems, pp. 6367–6377, 2018.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 213, + 506, + 225 + ], + "spans": [ + { + "bbox": [ + 106, + 213, + 506, + 225 + ], + "score": 1.0, + "content": "[32] H. Zhang, T.-W. Weng, P.-Y. Chen, C.-J. Hsieh, and L. Daniel, “Efficient neural network", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 127, + 223, + 505, + 236 + ], + "spans": [ + { + "bbox": [ + 127, + 223, + 505, + 236 + ], + "score": 1.0, + "content": "robustness certification with general activation functions,” in Advances in neural information", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 126, + 235, + 299, + 246 + ], + "spans": [ + { + "bbox": [ + 126, + 235, + 299, + 246 + ], + "score": 1.0, + "content": "processing systems, pp. 4939–4948, 2018.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 249, + 506, + 262 + ], + "spans": [ + { + "bbox": [ + 106, + 249, + 506, + 262 + ], + "score": 1.0, + "content": "[33] A. Boopathy, T.-W. Weng, P.-Y. Chen, S. Liu, and L. Daniel, “Cnn-cert: An efficient frame-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 127, + 261, + 506, + 273 + ], + "spans": [ + { + "bbox": [ + 127, + 261, + 506, + 273 + ], + "score": 1.0, + "content": "work for certifying robustness of convolutional neural networks,” in Proceedings of the AAAI", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 128, + 271, + 400, + 284 + ], + "spans": [ + { + "bbox": [ + 128, + 271, + 400, + 284 + ], + "score": 1.0, + "content": "Conference on Artificial Intelligence, vol. 33, pp. 3240–3247, 2019.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 286, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 106, + 286, + 506, + 299 + ], + "score": 1.0, + "content": "[34] V. Tjeng, K. Y. Xiao, and R. Tedrake, “Evaluating robustness of neural networks with mixed", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 127, + 297, + 480, + 309 + ], + "spans": [ + { + "bbox": [ + 127, + 297, + 480, + 309 + ], + "score": 1.0, + "content": "integer programming,” in International Conference on Learning Representations, 2018.", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 312, + 506, + 324 + ], + "spans": [ + { + "bbox": [ + 106, + 312, + 506, + 324 + ], + "score": 1.0, + "content": "[35] M. G. Bellemare, Y. Naddaf, J. Veness, and M. Bowling, “The arcade learning environment:", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 127, + 323, + 506, + 336 + ], + "spans": [ + { + "bbox": [ + 127, + 323, + 506, + 336 + ], + "score": 1.0, + "content": "An evaluation platform for general agents,” Journal of Artificial Intelligence Research, vol. 47,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 126, + 334, + 219, + 345 + ], + "spans": [ + { + "bbox": [ + 126, + 334, + 219, + 345 + ], + "score": 1.0, + "content": "p. 253–279, Jun 2013.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 349, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 106, + 349, + 506, + 361 + ], + "score": 1.0, + "content": "[36] K. Cobbe, C. Hesse, J. Hilton, and J. Schulman, “Leveraging procedural generation to bench-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 127, + 360, + 506, + 372 + ], + "spans": [ + { + "bbox": [ + 127, + 360, + 506, + 372 + ], + "score": 1.0, + "content": "mark reinforcement learning,” in International conference on machine learning, pp. 2048–2056,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 128, + 371, + 185, + 381 + ], + "spans": [ + { + "bbox": [ + 128, + 371, + 185, + 381 + ], + "score": 1.0, + "content": "PMLR, 2020.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 385, + 506, + 398 + ], + "spans": [ + { + "bbox": [ + 106, + 385, + 506, + 398 + ], + "score": 1.0, + "content": "[37] E. Todorov, T. Erez, and Y. Tassa, “Mujoco: A physics engine for model-based control,” in 2012", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 127, + 397, + 504, + 409 + ], + "spans": [ + { + "bbox": [ + 127, + 397, + 504, + 409 + ], + "score": 1.0, + "content": "IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 5026–5033, 2012.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 412, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 106, + 412, + 505, + 423 + ], + "score": 1.0, + "content": "[38] H. Zhang, H. Chen, C. Xiao, S. Gowal, R. Stanforth, B. Li, D. Boning, and C.-J. Hsieh, “Towards", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 127, + 422, + 505, + 435 + ], + "spans": [ + { + "bbox": [ + 127, + 422, + 505, + 435 + ], + "score": 1.0, + "content": "stable and efficient training of verifiably robust neural networks,” in International Conference", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 127, + 433, + 273, + 446 + ], + "spans": [ + { + "bbox": [ + 127, + 433, + 273, + 446 + ], + "score": 1.0, + "content": "on Learning Representations, 2020.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 449, + 475, + 460 + ], + "spans": [ + { + "bbox": [ + 106, + 449, + 475, + 460 + ], + "score": 1.0, + "content": "[39] D. P. Kingma and J. Ba, “Adam: A method for stochastic optimization,” in ICLR 2015.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 15 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 311, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 312, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 312, + 754 + ], + "score": 1.0, + "content": "12", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 105, + 69, + 507, + 465 + ], + "lines": [], + "index": 15, + "bbox_fs": [ + 105, + 73, + 506, + 460 + ], + "lines_deleted": true + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file