diff --git "a/parse/train/S1exA2NtDB/S1exA2NtDB_middle.json" "b/parse/train/S1exA2NtDB/S1exA2NtDB_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/S1exA2NtDB/S1exA2NtDB_middle.json" @@ -0,0 +1,50240 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 78, + 503, + 97 + ], + "lines": [ + { + "bbox": [ + 105, + 78, + 506, + 99 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 506, + 99 + ], + "score": 1.0, + "content": "ES-MAML: SIMPLE HESSIAN-FREE META LEARNING", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 112, + 114, + 351, + 149 + ], + "lines": [ + { + "bbox": [ + 111, + 114, + 353, + 128 + ], + "spans": [ + { + "bbox": [ + 111, + 114, + 353, + 128 + ], + "score": 1.0, + "content": "Xingyou Song∗, Yuxiang Yang‡, Krzysztof Choromanski", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 112, + 126, + 169, + 138 + ], + "spans": [ + { + "bbox": [ + 112, + 126, + 169, + 138 + ], + "score": 1.0, + "content": "Google Brain", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 113, + 137, + 340, + 150 + ], + "spans": [ + { + "bbox": [ + 113, + 137, + 340, + 150 + ], + "score": 1.0, + "content": "{xingyousong,yxyang,kchoro}@google.com", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 365, + 115, + 498, + 149 + ], + "lines": [ + { + "bbox": [ + 365, + 114, + 434, + 127 + ], + "spans": [ + { + "bbox": [ + 365, + 114, + 434, + 127 + ], + "score": 1.0, + "content": "Aldo Pacchiano", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 363, + 125, + 420, + 139 + ], + "spans": [ + { + "bbox": [ + 363, + 125, + 420, + 139 + ], + "score": 1.0, + "content": "UC Berkeley", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 363, + 137, + 499, + 149 + ], + "spans": [ + { + "bbox": [ + 363, + 137, + 499, + 149 + ], + "score": 1.0, + "content": "pacchiano@berkeley.edu", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 113, + 164, + 280, + 199 + ], + "lines": [ + { + "bbox": [ + 112, + 164, + 238, + 178 + ], + "spans": [ + { + "bbox": [ + 112, + 164, + 144, + 178 + ], + "score": 1.0, + "content": "Wenbo", + "type": "text" + }, + { + "bbox": [ + 145, + 164, + 171, + 176 + ], + "score": 0.52, + "content": "\\mathbf { G a o ^ { * } } ^ { \\dagger }", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 164, + 238, + 178 + ], + "score": 1.0, + "content": ", Yunhao Tang†", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 111, + 174, + 199, + 189 + ], + "spans": [ + { + "bbox": [ + 111, + 174, + 199, + 189 + ], + "score": 1.0, + "content": "Columbia University", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 113, + 187, + 280, + 200 + ], + "spans": [ + { + "bbox": [ + 113, + 187, + 204, + 200 + ], + "score": 0.28, + "content": "\\{ \\mathrm { w g } 2 2 7 9 , \\mathrm { y t } 2 5 4 \\dot { 1 } \\} (", + "type": "inline_equation" + }, + { + "bbox": [ + 204, + 187, + 280, + 200 + ], + "score": 1.0, + "content": "@columbia.edu", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8 + }, + { + "type": "title", + "bbox": [ + 278, + 227, + 333, + 240 + ], + "lines": [ + { + "bbox": [ + 277, + 227, + 335, + 241 + ], + "spans": [ + { + "bbox": [ + 277, + 227, + 335, + 241 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 143, + 253, + 468, + 375 + ], + "lines": [ + { + "bbox": [ + 142, + 253, + 469, + 266 + ], + "spans": [ + { + "bbox": [ + 142, + 253, + 469, + 266 + ], + "score": 1.0, + "content": "We introduce ES-MAML, a new framework for solving the model agnostic meta", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 264, + 469, + 278 + ], + "spans": [ + { + "bbox": [ + 141, + 264, + 469, + 278 + ], + "score": 1.0, + "content": "learning (MAML) problem based on Evolution Strategies (ES). Existing algo-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 275, + 469, + 289 + ], + "spans": [ + { + "bbox": [ + 141, + 275, + 469, + 289 + ], + "score": 1.0, + "content": "rithms for MAML are based on policy gradients, and incur significant difficulties", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 287, + 469, + 299 + ], + "spans": [ + { + "bbox": [ + 141, + 287, + 469, + 299 + ], + "score": 1.0, + "content": "when attempting to estimate second derivatives using backpropagation on stochas-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 142, + 298, + 469, + 310 + ], + "spans": [ + { + "bbox": [ + 142, + 298, + 469, + 310 + ], + "score": 1.0, + "content": "tic policies. We show how ES can be applied to MAML to obtain an algorithm", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 308, + 469, + 322 + ], + "spans": [ + { + "bbox": [ + 141, + 308, + 469, + 322 + ], + "score": 1.0, + "content": "which avoids the problem of estimating second derivatives, and is also conceptu-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 319, + 470, + 333 + ], + "spans": [ + { + "bbox": [ + 141, + 319, + 470, + 333 + ], + "score": 1.0, + "content": "ally simple and easy to implement. Moreover, ES-MAML can handle new types", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 331, + 469, + 343 + ], + "spans": [ + { + "bbox": [ + 141, + 331, + 469, + 343 + ], + "score": 1.0, + "content": "of non-smooth adaptation operators, and other techniques for improving perfor-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 342, + 469, + 354 + ], + "spans": [ + { + "bbox": [ + 141, + 342, + 469, + 354 + ], + "score": 1.0, + "content": "mance and estimation of ES methods become applicable. We show empirically", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 351, + 469, + 366 + ], + "spans": [ + { + "bbox": [ + 141, + 351, + 469, + 366 + ], + "score": 1.0, + "content": "that ES-MAML is competitive with existing methods and often yields better adap-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 142, + 363, + 246, + 376 + ], + "spans": [ + { + "bbox": [ + 142, + 363, + 246, + 376 + ], + "score": 1.0, + "content": "tation with fewer queries.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 16 + }, + { + "type": "title", + "bbox": [ + 108, + 420, + 206, + 433 + ], + "lines": [ + { + "bbox": [ + 105, + 419, + 208, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 208, + 436 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 446, + 505, + 534 + ], + "lines": [ + { + "bbox": [ + 105, + 446, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 505, + 460 + ], + "score": 1.0, + "content": "Meta-learning is a paradigm in machine learning that aims to develop models and training algo-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 458, + 505, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 505, + 470 + ], + "score": 1.0, + "content": "rithms which can quickly adapt to new tasks and data. Our focus in this paper is on meta-learning in", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 468, + 505, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 468, + 505, + 482 + ], + "score": 1.0, + "content": "reinforcement learning (RL), where data efficiency is of paramount importance because gathering", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 480, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 505, + 492 + ], + "score": 1.0, + "content": "new samples often requires costly simulations or interactions with the real world. A popular tech-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 490, + 506, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 490, + 506, + 504 + ], + "score": 1.0, + "content": "nique for RL meta-learning is Model Agnostic Meta Learning (MAML) (Finn et al., 2017; 2018), a", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 501, + 506, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 506, + 515 + ], + "score": 1.0, + "content": "model for training an agent which can quickly adapt to new and unknown tasks by performing one", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "score": 1.0, + "content": "(or a few) gradient updates in the new environment. We provide a formal description of MAML in", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 523, + 150, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 150, + 535 + ], + "score": 1.0, + "content": "Section 2.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 106, + 540, + 505, + 650 + ], + "lines": [ + { + "bbox": [ + 104, + 538, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 104, + 538, + 505, + 554 + ], + "score": 1.0, + "content": "MAML has proven to be successful for many applications. However, implementing and running", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 550, + 506, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 506, + 564 + ], + "score": 1.0, + "content": "MAML continues to be challenging. One major complication is that the standard version of MAML", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 104, + 560, + 506, + 576 + ], + "spans": [ + { + "bbox": [ + 104, + 560, + 506, + 576 + ], + "score": 1.0, + "content": "requires estimating second derivatives of the RL reward function, which is difficult when using", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 573, + 505, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 505, + 586 + ], + "score": 1.0, + "content": "backpropagation on stochastic policies; indeed, the original implementation of MAML (Finn et al.,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 583, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 506, + 596 + ], + "score": 1.0, + "content": "2017) did so incorrectly, which spurred the development of unbiased higher-order estimators (DiCE,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 595, + 505, + 608 + ], + "spans": [ + { + "bbox": [ + 106, + 595, + 505, + 608 + ], + "score": 1.0, + "content": "(Foerster et al., 2018)) and further analysis of the credit assignment mechanism in MAML (Rothfuss", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 606, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 106, + 606, + 505, + 618 + ], + "score": 1.0, + "content": "et al., 2019). Another challenge arises from the high variance inherent in policy gradient methods,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 617, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 106, + 617, + 505, + 630 + ], + "score": 1.0, + "content": "which can be ameliorated through control variates such as in T-MAML (Liu et al., 2019), through", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 628, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 106, + 628, + 505, + 640 + ], + "score": 1.0, + "content": "careful adaptive hyperparameter tuning (Behl et al., 2019; Antoniou et al., 2019) and learning rate", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 639, + 268, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 268, + 651 + ], + "score": 1.0, + "content": "annealing (Loshchilov & Hutter, 2017).", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 108, + 656, + 504, + 689 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 669 + ], + "score": 1.0, + "content": "To avoid these issues, we propose an alternative approach to MAML based on Evolution Strategies", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 505, + 679 + ], + "score": 1.0, + "content": "(ES), as opposed to the policy gradient underlying previous MAML algorithms. We provide a", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 677, + 379, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 379, + 690 + ], + "score": 1.0, + "content": "detailed discussion of ES in Section 3.1. ES has several advantages:", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 123, + 701, + 468, + 732 + ], + "lines": [ + { + "bbox": [ + 122, + 698, + 199, + 711 + ], + "spans": [ + { + "bbox": [ + 122, + 698, + 199, + 711 + ], + "score": 1.0, + "content": "∗Equal contribution.", + "type": "text" + } + ] + }, + { + "bbox": [ + 122, + 707, + 283, + 724 + ], + "spans": [ + { + "bbox": [ + 122, + 707, + 283, + 724 + ], + "score": 1.0, + "content": "†Work performed during Google internship.", + "type": "text" + } + ] + }, + { + "bbox": [ + 121, + 717, + 469, + 735 + ], + "spans": [ + { + "bbox": [ + 121, + 717, + 469, + 735 + ], + "score": 1.0, + "content": "‡Work performed during the Google AI Residency Program. http://g.co/airesidency", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 294, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "1", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 78, + 503, + 97 + ], + "lines": [ + { + "bbox": [ + 105, + 78, + 506, + 99 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 506, + 99 + ], + "score": 1.0, + "content": "ES-MAML: SIMPLE HESSIAN-FREE META LEARNING", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 112, + 114, + 351, + 149 + ], + "lines": [ + { + "bbox": [ + 111, + 114, + 353, + 128 + ], + "spans": [ + { + "bbox": [ + 111, + 114, + 353, + 128 + ], + "score": 1.0, + "content": "Xingyou Song∗, Yuxiang Yang‡, Krzysztof Choromanski", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 112, + 126, + 169, + 138 + ], + "spans": [ + { + "bbox": [ + 112, + 126, + 169, + 138 + ], + "score": 1.0, + "content": "Google Brain", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 113, + 137, + 340, + 150 + ], + "spans": [ + { + "bbox": [ + 113, + 137, + 340, + 150 + ], + "score": 1.0, + "content": "{xingyousong,yxyang,kchoro}@google.com", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3, + "bbox_fs": [ + 111, + 114, + 353, + 150 + ] + }, + { + "type": "list", + "bbox": [ + 365, + 115, + 498, + 149 + ], + "lines": [ + { + "bbox": [ + 365, + 114, + 434, + 127 + ], + "spans": [ + { + "bbox": [ + 365, + 114, + 434, + 127 + ], + "score": 1.0, + "content": "Aldo Pacchiano", + "type": "text" + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 363, + 125, + 420, + 139 + ], + "spans": [ + { + "bbox": [ + 363, + 125, + 420, + 139 + ], + "score": 1.0, + "content": "UC Berkeley", + "type": "text" + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 363, + 137, + 499, + 149 + ], + "spans": [ + { + "bbox": [ + 363, + 137, + 499, + 149 + ], + "score": 1.0, + "content": "pacchiano@berkeley.edu", + "type": "text" + } + ], + "index": 6, + "is_list_start_line": true + } + ], + "index": 4, + "bbox_fs": [ + 363, + 114, + 499, + 149 + ] + }, + { + "type": "text", + "bbox": [ + 113, + 164, + 280, + 199 + ], + "lines": [ + { + "bbox": [ + 112, + 164, + 238, + 178 + ], + "spans": [ + { + "bbox": [ + 112, + 164, + 144, + 178 + ], + "score": 1.0, + "content": "Wenbo", + "type": "text" + }, + { + "bbox": [ + 145, + 164, + 171, + 176 + ], + "score": 0.52, + "content": "\\mathbf { G a o ^ { * } } ^ { \\dagger }", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 164, + 238, + 178 + ], + "score": 1.0, + "content": ", Yunhao Tang†", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 111, + 174, + 199, + 189 + ], + "spans": [ + { + "bbox": [ + 111, + 174, + 199, + 189 + ], + "score": 1.0, + "content": "Columbia University", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 113, + 187, + 280, + 200 + ], + "spans": [ + { + "bbox": [ + 113, + 187, + 204, + 200 + ], + "score": 0.28, + "content": "\\{ \\mathrm { w g } 2 2 7 9 , \\mathrm { y t } 2 5 4 \\dot { 1 } \\} (", + "type": "inline_equation" + }, + { + "bbox": [ + 204, + 187, + 280, + 200 + ], + "score": 1.0, + "content": "@columbia.edu", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8, + "bbox_fs": [ + 111, + 164, + 280, + 200 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 227, + 333, + 240 + ], + "lines": [ + { + "bbox": [ + 277, + 227, + 335, + 241 + ], + "spans": [ + { + "bbox": [ + 277, + 227, + 335, + 241 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 143, + 253, + 468, + 375 + ], + "lines": [ + { + "bbox": [ + 142, + 253, + 469, + 266 + ], + "spans": [ + { + "bbox": [ + 142, + 253, + 469, + 266 + ], + "score": 1.0, + "content": "We introduce ES-MAML, a new framework for solving the model agnostic meta", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 264, + 469, + 278 + ], + "spans": [ + { + "bbox": [ + 141, + 264, + 469, + 278 + ], + "score": 1.0, + "content": "learning (MAML) problem based on Evolution Strategies (ES). Existing algo-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 275, + 469, + 289 + ], + "spans": [ + { + "bbox": [ + 141, + 275, + 469, + 289 + ], + "score": 1.0, + "content": "rithms for MAML are based on policy gradients, and incur significant difficulties", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 287, + 469, + 299 + ], + "spans": [ + { + "bbox": [ + 141, + 287, + 469, + 299 + ], + "score": 1.0, + "content": "when attempting to estimate second derivatives using backpropagation on stochas-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 142, + 298, + 469, + 310 + ], + "spans": [ + { + "bbox": [ + 142, + 298, + 469, + 310 + ], + "score": 1.0, + "content": "tic policies. We show how ES can be applied to MAML to obtain an algorithm", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 308, + 469, + 322 + ], + "spans": [ + { + "bbox": [ + 141, + 308, + 469, + 322 + ], + "score": 1.0, + "content": "which avoids the problem of estimating second derivatives, and is also conceptu-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 319, + 470, + 333 + ], + "spans": [ + { + "bbox": [ + 141, + 319, + 470, + 333 + ], + "score": 1.0, + "content": "ally simple and easy to implement. Moreover, ES-MAML can handle new types", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 331, + 469, + 343 + ], + "spans": [ + { + "bbox": [ + 141, + 331, + 469, + 343 + ], + "score": 1.0, + "content": "of non-smooth adaptation operators, and other techniques for improving perfor-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 342, + 469, + 354 + ], + "spans": [ + { + "bbox": [ + 141, + 342, + 469, + 354 + ], + "score": 1.0, + "content": "mance and estimation of ES methods become applicable. We show empirically", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 351, + 469, + 366 + ], + "spans": [ + { + "bbox": [ + 141, + 351, + 469, + 366 + ], + "score": 1.0, + "content": "that ES-MAML is competitive with existing methods and often yields better adap-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 142, + 363, + 246, + 376 + ], + "spans": [ + { + "bbox": [ + 142, + 363, + 246, + 376 + ], + "score": 1.0, + "content": "tation with fewer queries.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 16, + "bbox_fs": [ + 141, + 253, + 470, + 376 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 420, + 206, + 433 + ], + "lines": [ + { + "bbox": [ + 105, + 419, + 208, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 208, + 436 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 446, + 505, + 534 + ], + "lines": [ + { + "bbox": [ + 105, + 446, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 505, + 460 + ], + "score": 1.0, + "content": "Meta-learning is a paradigm in machine learning that aims to develop models and training algo-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 458, + 505, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 505, + 470 + ], + "score": 1.0, + "content": "rithms which can quickly adapt to new tasks and data. Our focus in this paper is on meta-learning in", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 468, + 505, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 468, + 505, + 482 + ], + "score": 1.0, + "content": "reinforcement learning (RL), where data efficiency is of paramount importance because gathering", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 480, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 505, + 492 + ], + "score": 1.0, + "content": "new samples often requires costly simulations or interactions with the real world. A popular tech-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 490, + 506, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 490, + 506, + 504 + ], + "score": 1.0, + "content": "nique for RL meta-learning is Model Agnostic Meta Learning (MAML) (Finn et al., 2017; 2018), a", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 501, + 506, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 506, + 515 + ], + "score": 1.0, + "content": "model for training an agent which can quickly adapt to new and unknown tasks by performing one", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "score": 1.0, + "content": "(or a few) gradient updates in the new environment. We provide a formal description of MAML in", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 523, + 150, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 150, + 535 + ], + "score": 1.0, + "content": "Section 2.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 446, + 506, + 535 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 540, + 505, + 650 + ], + "lines": [ + { + "bbox": [ + 104, + 538, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 104, + 538, + 505, + 554 + ], + "score": 1.0, + "content": "MAML has proven to be successful for many applications. However, implementing and running", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 550, + 506, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 506, + 564 + ], + "score": 1.0, + "content": "MAML continues to be challenging. One major complication is that the standard version of MAML", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 104, + 560, + 506, + 576 + ], + "spans": [ + { + "bbox": [ + 104, + 560, + 506, + 576 + ], + "score": 1.0, + "content": "requires estimating second derivatives of the RL reward function, which is difficult when using", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 573, + 505, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 505, + 586 + ], + "score": 1.0, + "content": "backpropagation on stochastic policies; indeed, the original implementation of MAML (Finn et al.,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 583, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 506, + 596 + ], + "score": 1.0, + "content": "2017) did so incorrectly, which spurred the development of unbiased higher-order estimators (DiCE,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 595, + 505, + 608 + ], + "spans": [ + { + "bbox": [ + 106, + 595, + 505, + 608 + ], + "score": 1.0, + "content": "(Foerster et al., 2018)) and further analysis of the credit assignment mechanism in MAML (Rothfuss", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 606, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 106, + 606, + 505, + 618 + ], + "score": 1.0, + "content": "et al., 2019). Another challenge arises from the high variance inherent in policy gradient methods,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 617, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 106, + 617, + 505, + 630 + ], + "score": 1.0, + "content": "which can be ameliorated through control variates such as in T-MAML (Liu et al., 2019), through", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 628, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 106, + 628, + 505, + 640 + ], + "score": 1.0, + "content": "careful adaptive hyperparameter tuning (Behl et al., 2019; Antoniou et al., 2019) and learning rate", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 639, + 268, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 268, + 651 + ], + "score": 1.0, + "content": "annealing (Loshchilov & Hutter, 2017).", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 35.5, + "bbox_fs": [ + 104, + 538, + 506, + 651 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 656, + 504, + 689 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 669 + ], + "score": 1.0, + "content": "To avoid these issues, we propose an alternative approach to MAML based on Evolution Strategies", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 505, + 679 + ], + "score": 1.0, + "content": "(ES), as opposed to the policy gradient underlying previous MAML algorithms. We provide a", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 677, + 379, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 379, + 690 + ], + "score": 1.0, + "content": "detailed discussion of ES in Section 3.1. ES has several advantages:", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42, + "bbox_fs": [ + 105, + 655, + 505, + 690 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 130, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 129, + 81, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 129, + 81, + 505, + 95 + ], + "score": 1.0, + "content": "1. Our zero-order formulation of ES-MAML (Section 3.2, Algorithm 3) does not require es-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 142, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 142, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "timating any second derivatives. This dodges the many issues caused by estimating second", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 141, + 104, + 472, + 118 + ], + "spans": [ + { + "bbox": [ + 141, + 104, + 472, + 118 + ], + "score": 1.0, + "content": "derivatives with backpropagation on stochastic policies (see Section 2 for details).", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 126, + 121, + 503, + 144 + ], + "lines": [ + { + "bbox": [ + 129, + 121, + 505, + 134 + ], + "spans": [ + { + "bbox": [ + 129, + 121, + 505, + 134 + ], + "score": 1.0, + "content": "2. ES is conceptually much simpler than policy gradients, which also translates to ease of", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 141, + 132, + 465, + 145 + ], + "spans": [ + { + "bbox": [ + 141, + 132, + 465, + 145 + ], + "score": 1.0, + "content": "implementation. It does not use backpropagation, so it can be run on CPUs only.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 130, + 149, + 422, + 160 + ], + "lines": [ + { + "bbox": [ + 128, + 147, + 422, + 163 + ], + "spans": [ + { + "bbox": [ + 128, + 147, + 422, + 163 + ], + "score": 1.0, + "content": "3. ES is highly flexible with different adaptation operators (Section 3.3).", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 130, + 166, + 504, + 189 + ], + "lines": [ + { + "bbox": [ + 129, + 166, + 504, + 178 + ], + "spans": [ + { + "bbox": [ + 129, + 166, + 504, + 178 + ], + "score": 1.0, + "content": "4. ES allows us to use deterministic policies, which can be safer when doing adaptation (Sec-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 176, + 493, + 190 + ], + "spans": [ + { + "bbox": [ + 141, + 176, + 493, + 190 + ], + "score": 1.0, + "content": "tion 4.3). ES is also capable of learning linear and other compact policies (Section 4.2).", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 106, + 199, + 505, + 309 + ], + "lines": [ + { + "bbox": [ + 106, + 199, + 505, + 212 + ], + "spans": [ + { + "bbox": [ + 106, + 199, + 505, + 212 + ], + "score": 1.0, + "content": "On the point (4), a feature of ES algorithms is that exploration takes place in the parameter space.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 209, + 506, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 506, + 223 + ], + "score": 1.0, + "content": "Whereas policy gradient methods are primarily motivated by interactions with the environment", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 221, + 506, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 506, + 234 + ], + "score": 1.0, + "content": "through randomized actions, ES is driven by optimization in high-dimensional parameter spaces", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 232, + 506, + 244 + ], + "spans": [ + { + "bbox": [ + 106, + 232, + 506, + 244 + ], + "score": 1.0, + "content": "with an expensive querying model. In the context of MAML, the notions of “exploration” and “task", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 242, + 506, + 256 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 506, + 256 + ], + "score": 1.0, + "content": "identification” have thus been shifted to the parameter space instead of the action space. This dis-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 254, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 505, + 267 + ], + "score": 1.0, + "content": "tinction plays a key role in the stability of the algorithm. One immediate implication is that we can", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 264, + 506, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 506, + 277 + ], + "score": 1.0, + "content": "use deterministic policies, unlike policy gradients which is based on stochastic policies. Another", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 276, + 504, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 504, + 288 + ], + "score": 1.0, + "content": "difference is that ES uses only the total reward and not the individual state-action pairs within each", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 286, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 505, + 299 + ], + "score": 1.0, + "content": "episode. While this may appear to be a weakness, since less information is being used, we find in", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 298, + 349, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 349, + 310 + ], + "score": 1.0, + "content": "practice that it seems to lead to more stable training profiles.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 107, + 314, + 505, + 381 + ], + "lines": [ + { + "bbox": [ + 106, + 314, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 314, + 506, + 327 + ], + "score": 1.0, + "content": "This paper is organized as follows. In Section 2, we give a formal definition of MAML, and discuss", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 325, + 504, + 337 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 504, + 337 + ], + "score": 1.0, + "content": "related works. In Section 3, we introduce Evolutionary Strategies and show how ES can be applied", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 335, + 505, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 505, + 350 + ], + "score": 1.0, + "content": "to create a new framework for MAML. In Section 4, we present numerical experiments, highlighting", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 347, + 505, + 360 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 505, + 360 + ], + "score": 1.0, + "content": "the topics of exploration (Section 4.1), the utility of compact architectures (Section 4.2), the stability", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 358, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 505, + 371 + ], + "score": 1.0, + "content": "of deterministic policies (Section 4.3), and comparisons against existing MAML algorithms in the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 369, + 434, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 369, + 434, + 382 + ], + "score": 1.0, + "content": "few-shot regime (Section 4.4). Additional material can be found in the Appendix.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20.5 + }, + { + "type": "title", + "bbox": [ + 107, + 398, + 348, + 412 + ], + "lines": [ + { + "bbox": [ + 105, + 398, + 349, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 349, + 413 + ], + "score": 1.0, + "content": "2 MODEL AGNOSTIC META LEARNING IN RL", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 425, + 505, + 514 + ], + "lines": [ + { + "bbox": [ + 106, + 425, + 505, + 438 + ], + "spans": [ + { + "bbox": [ + 106, + 425, + 424, + 438 + ], + "score": 1.0, + "content": "We first discuss the original formulation of MAML (Finn et al., 2017). Let", + "type": "text" + }, + { + "bbox": [ + 424, + 426, + 434, + 436 + ], + "score": 0.82, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 425, + 505, + 438 + ], + "score": 1.0, + "content": "be a set of rein-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 436, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 436, + 361, + 448 + ], + "score": 1.0, + "content": "forcement learning tasks with common state and action spaces", + "type": "text" + }, + { + "bbox": [ + 361, + 437, + 381, + 448 + ], + "score": 0.88, + "content": "s , A", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 436, + 403, + 448 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 403, + 437, + 427, + 448 + ], + "score": 0.92, + "content": "\\mathcal { P } ( \\mathcal { T } )", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 436, + 505, + 448 + ], + "score": 1.0, + "content": "a distribution over", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 107, + 446, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 107, + 448, + 116, + 458 + ], + "score": 0.8, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 116, + 446, + 291, + 460 + ], + "score": 1.0, + "content": ". In the standard MAML setting, each task", + "type": "text" + }, + { + "bbox": [ + 292, + 448, + 325, + 459 + ], + "score": 0.92, + "content": "T _ { i } \\in \\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 446, + 505, + 460 + ], + "score": 1.0, + "content": "has an associated Markov Decision Process", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 458, + 503, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 246, + 472 + ], + "score": 1.0, + "content": "(MDP) with transition distribution", + "type": "text" + }, + { + "bbox": [ + 247, + 459, + 306, + 470 + ], + "score": 0.92, + "content": "q _ { i } ( s _ { t + 1 } | s _ { t } , a _ { t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 458, + 382, + 472 + ], + "score": 1.0, + "content": ", an episode length", + "type": "text" + }, + { + "bbox": [ + 382, + 459, + 393, + 469 + ], + "score": 0.81, + "content": "H", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 458, + 487, + 472 + ], + "score": 1.0, + "content": ", and a reward function", + "type": "text" + }, + { + "bbox": [ + 487, + 459, + 503, + 470 + ], + "score": 0.89, + "content": "R _ { T _ { i } }", + "type": "inline_equation" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 469, + 506, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 205, + 483 + ], + "score": 1.0, + "content": "which maps a trajectory", + "type": "text" + }, + { + "bbox": [ + 205, + 470, + 313, + 482 + ], + "score": 0.88, + "content": "\\tau = ( s _ { 0 } , a _ { 1 } , . . . , a _ { H - 1 } , s _ { H } )", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 469, + 390, + 483 + ], + "score": 1.0, + "content": "to the total reward", + "type": "text" + }, + { + "bbox": [ + 390, + 469, + 412, + 482 + ], + "score": 0.92, + "content": "R ( \\tau )", + "type": "inline_equation" + }, + { + "bbox": [ + 412, + 469, + 506, + 483 + ], + "score": 1.0, + "content": ". A stochastic policy is", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 479, + 506, + 493 + ], + "spans": [ + { + "bbox": [ + 104, + 479, + 150, + 493 + ], + "score": 1.0, + "content": "a function", + "type": "text" + }, + { + "bbox": [ + 150, + 480, + 215, + 492 + ], + "score": 0.93, + "content": "\\pi : { \\mathcal { S } } { \\mathcal { P } } ( { \\mathcal { A } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 215, + 479, + 506, + 493 + ], + "score": 1.0, + "content": "which maps states to probability distributions over the action space. A", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 491, + 506, + 504 + ], + "spans": [ + { + "bbox": [ + 106, + 491, + 242, + 504 + ], + "score": 1.0, + "content": "deterministic policy is a function", + "type": "text" + }, + { + "bbox": [ + 242, + 492, + 292, + 502 + ], + "score": 0.9, + "content": "\\pi : { \\mathcal { S } } A", + "type": "inline_equation" + }, + { + "bbox": [ + 292, + 491, + 506, + 504 + ], + "score": 1.0, + "content": ". Policies are typically encoded by a neural network", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 503, + 375, + 515 + ], + "spans": [ + { + "bbox": [ + 106, + 503, + 173, + 515 + ], + "score": 1.0, + "content": "with parameters", + "type": "text" + }, + { + "bbox": [ + 173, + 503, + 179, + 512 + ], + "score": 0.76, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 180, + 503, + 310, + 515 + ], + "score": 1.0, + "content": ", and we often refer to the policy", + "type": "text" + }, + { + "bbox": [ + 310, + 504, + 322, + 514 + ], + "score": 0.86, + "content": "\\pi _ { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 503, + 365, + 515 + ], + "score": 1.0, + "content": "simply by", + "type": "text" + }, + { + "bbox": [ + 365, + 503, + 371, + 512 + ], + "score": 0.81, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 371, + 503, + 375, + 515 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 107, + 519, + 505, + 563 + ], + "lines": [ + { + "bbox": [ + 106, + 519, + 506, + 531 + ], + "spans": [ + { + "bbox": [ + 106, + 519, + 506, + 531 + ], + "score": 1.0, + "content": "The MAML problem is to find the so-called MAML point (called also a meta-policy), which is a", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 529, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 133, + 543 + ], + "score": 1.0, + "content": "policy", + "type": "text" + }, + { + "bbox": [ + 134, + 530, + 145, + 540 + ], + "score": 0.84, + "content": "\\theta ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 529, + 371, + 543 + ], + "score": 1.0, + "content": "that can be ‘adapted’ quickly to solve an unknown task", + "type": "text" + }, + { + "bbox": [ + 371, + 531, + 401, + 541 + ], + "score": 0.87, + "content": "T \\in { \\mathcal { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 529, + 505, + 543 + ], + "score": 1.0, + "content": "by taking a (few)1 policy", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 541, + 506, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 226, + 554 + ], + "score": 1.0, + "content": "gradient steps with respect to", + "type": "text" + }, + { + "bbox": [ + 226, + 542, + 235, + 551 + ], + "score": 0.81, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 541, + 506, + 554 + ], + "score": 1.0, + "content": ". The optimization problem to be solved in training (in its one-shot", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 552, + 220, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 220, + 564 + ], + "score": 1.0, + "content": "version) is thus of the form:", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34.5 + }, + { + "type": "interline_equation", + "bbox": [ + 208, + 570, + 403, + 589 + ], + "lines": [ + { + "bbox": [ + 208, + 570, + 403, + 589 + ], + "spans": [ + { + "bbox": [ + 208, + 570, + 403, + 589 + ], + "score": 0.89, + "content": "\\operatorname* { m a x } _ { \\theta } J ( \\theta ) : = \\mathbb { E } _ { T \\sim \\mathcal { P } ( \\mathcal { T } ) } [ \\mathbb { E } _ { \\tau ^ { \\prime } \\sim \\mathcal { P } _ { \\mathcal { T } } ( \\tau ^ { \\prime } \\mid \\theta ^ { \\prime } ) } [ R _ { T } ( \\tau ^ { \\prime } ) ] ] ,", + "type": "interline_equation", + "image_path": "5cf6926b28dbbb6bd07c6286c152dc3cb1f64db003ca22f8c12948c2473f51bd.jpg" + } + ] + } + ], + "index": 37, + "virtual_lines": [ + { + "bbox": [ + 208, + 570, + 403, + 589 + ], + "spans": [], + "index": 37 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 596, + 505, + 632 + ], + "lines": [ + { + "bbox": [ + 105, + 595, + 506, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 137, + 612 + ], + "score": 1.0, + "content": "where:", + "type": "text" + }, + { + "bbox": [ + 138, + 597, + 328, + 610 + ], + "score": 0.91, + "content": "\\theta ^ { \\prime } = U ( \\theta , T ) = \\theta + \\alpha \\nabla _ { \\theta } \\mathbb { E } _ { \\tau \\sim \\mathcal { P } _ { T } ( \\tau | \\theta ) } [ R _ { T } ( \\tau ) ]", + "type": "inline_equation" + }, + { + "bbox": [ + 328, + 595, + 506, + 612 + ], + "score": 1.0, + "content": "is called the adapted policy for a step size", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 107, + 607, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 107, + 609, + 133, + 619 + ], + "score": 0.88, + "content": "\\alpha > 0", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 607, + 150, + 622 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 150, + 609, + 183, + 621 + ], + "score": 0.92, + "content": "\\mathcal { P } _ { T } ( \\cdot | \\eta )", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 607, + 356, + 622 + ], + "score": 1.0, + "content": "is a distribution over trajectories given task", + "type": "text" + }, + { + "bbox": [ + 356, + 609, + 384, + 619 + ], + "score": 0.9, + "content": "T \\in { \\mathcal { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 607, + 505, + 622 + ], + "score": 1.0, + "content": "and conditioned on the policy", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 619, + 189, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 178, + 634 + ], + "score": 1.0, + "content": "parameterized by", + "type": "text" + }, + { + "bbox": [ + 178, + 623, + 184, + 632 + ], + "score": 0.8, + "content": "\\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 619, + 189, + 634 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 106, + 636, + 504, + 659 + ], + "lines": [ + { + "bbox": [ + 106, + 636, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 636, + 505, + 649 + ], + "score": 1.0, + "content": "Standard MAML approaches are based on the following expression for the gradient of the MAML", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 647, + 275, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 647, + 275, + 661 + ], + "score": 1.0, + "content": "objective function (1) to conduct training:", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + }, + { + "type": "interline_equation", + "bbox": [ + 155, + 666, + 455, + 681 + ], + "lines": [ + { + "bbox": [ + 155, + 666, + 455, + 681 + ], + "spans": [ + { + "bbox": [ + 155, + 666, + 455, + 681 + ], + "score": 0.88, + "content": "\\nabla _ { \\theta } J ( \\theta ) = \\mathbb { E } _ { T \\sim \\mathcal { P } ( \\mathcal { T } ) } [ \\mathbb { E } _ { r ^ { \\prime } \\sim \\mathcal { P } _ { T } ( \\tau ^ { \\prime } \\mid \\theta ^ { \\prime } ) } [ \\nabla _ { \\theta ^ { \\prime } } \\log \\mathcal { P } _ { T } ( \\tau ^ { \\prime } \\mid \\theta ^ { \\prime } ) R _ { T } ( \\tau ^ { \\prime } ) \\nabla _ { \\theta } U ( \\theta , T ) ] ] .", + "type": "interline_equation", + "image_path": "e19859288a13398f9e7a59655f53033778ab61b784dd0fe7f9fe408ecdd33d85.jpg" + } + ] + } + ], + "index": 43, + "virtual_lines": [ + { + "bbox": [ + 155, + 666, + 455, + 681 + ], + "spans": [], + "index": 43 + } + ] + }, + { + "type": "text", + "bbox": [ + 110, + 687, + 494, + 700 + ], + "lines": [ + { + "bbox": [ + 108, + 686, + 495, + 702 + ], + "spans": [ + { + "bbox": [ + 108, + 686, + 495, + 702 + ], + "score": 1.0, + "content": "We collectively refer to algorithms based on computing (2) using policy gradients as PG-MAML.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 44 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 105, + 711, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 118, + 709, + 505, + 724 + ], + "spans": [ + { + "bbox": [ + 118, + 709, + 505, + 724 + ], + "score": 1.0, + "content": "1We adopt the common convention of defining the adaptation operator with a single gradient step, to sim-", + "type": "text" + } + ] + }, + { + "bbox": [ + 105, + 720, + 292, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 292, + 733 + ], + "score": 1.0, + "content": "plify notation. It can be extended to multiple steps.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "score": 1.0, + "content": "2", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 130, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 129, + 81, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 129, + 81, + 505, + 95 + ], + "score": 1.0, + "content": "1. Our zero-order formulation of ES-MAML (Section 3.2, Algorithm 3) does not require es-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 142, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 142, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "timating any second derivatives. This dodges the many issues caused by estimating second", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 141, + 104, + 472, + 118 + ], + "spans": [ + { + "bbox": [ + 141, + 104, + 472, + 118 + ], + "score": 1.0, + "content": "derivatives with backpropagation on stochastic policies (see Section 2 for details).", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 129, + 81, + 505, + 118 + ] + }, + { + "type": "text", + "bbox": [ + 126, + 121, + 503, + 144 + ], + "lines": [ + { + "bbox": [ + 129, + 121, + 505, + 134 + ], + "spans": [ + { + "bbox": [ + 129, + 121, + 505, + 134 + ], + "score": 1.0, + "content": "2. ES is conceptually much simpler than policy gradients, which also translates to ease of", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 141, + 132, + 465, + 145 + ], + "spans": [ + { + "bbox": [ + 141, + 132, + 465, + 145 + ], + "score": 1.0, + "content": "implementation. It does not use backpropagation, so it can be run on CPUs only.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5, + "bbox_fs": [ + 129, + 121, + 505, + 145 + ] + }, + { + "type": "text", + "bbox": [ + 130, + 149, + 422, + 160 + ], + "lines": [ + { + "bbox": [ + 128, + 147, + 422, + 163 + ], + "spans": [ + { + "bbox": [ + 128, + 147, + 422, + 163 + ], + "score": 1.0, + "content": "3. ES is highly flexible with different adaptation operators (Section 3.3).", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5, + "bbox_fs": [ + 128, + 147, + 422, + 163 + ] + }, + { + "type": "text", + "bbox": [ + 130, + 166, + 504, + 189 + ], + "lines": [ + { + "bbox": [ + 129, + 166, + 504, + 178 + ], + "spans": [ + { + "bbox": [ + 129, + 166, + 504, + 178 + ], + "score": 1.0, + "content": "4. ES allows us to use deterministic policies, which can be safer when doing adaptation (Sec-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 176, + 493, + 190 + ], + "spans": [ + { + "bbox": [ + 141, + 176, + 493, + 190 + ], + "score": 1.0, + "content": "tion 4.3). ES is also capable of learning linear and other compact policies (Section 4.2).", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5, + "bbox_fs": [ + 129, + 166, + 504, + 190 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 199, + 505, + 309 + ], + "lines": [ + { + "bbox": [ + 106, + 199, + 505, + 212 + ], + "spans": [ + { + "bbox": [ + 106, + 199, + 505, + 212 + ], + "score": 1.0, + "content": "On the point (4), a feature of ES algorithms is that exploration takes place in the parameter space.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 209, + 506, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 506, + 223 + ], + "score": 1.0, + "content": "Whereas policy gradient methods are primarily motivated by interactions with the environment", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 221, + 506, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 506, + 234 + ], + "score": 1.0, + "content": "through randomized actions, ES is driven by optimization in high-dimensional parameter spaces", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 232, + 506, + 244 + ], + "spans": [ + { + "bbox": [ + 106, + 232, + 506, + 244 + ], + "score": 1.0, + "content": "with an expensive querying model. In the context of MAML, the notions of “exploration” and “task", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 242, + 506, + 256 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 506, + 256 + ], + "score": 1.0, + "content": "identification” have thus been shifted to the parameter space instead of the action space. This dis-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 254, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 505, + 267 + ], + "score": 1.0, + "content": "tinction plays a key role in the stability of the algorithm. One immediate implication is that we can", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 264, + 506, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 506, + 277 + ], + "score": 1.0, + "content": "use deterministic policies, unlike policy gradients which is based on stochastic policies. Another", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 276, + 504, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 504, + 288 + ], + "score": 1.0, + "content": "difference is that ES uses only the total reward and not the individual state-action pairs within each", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 286, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 505, + 299 + ], + "score": 1.0, + "content": "episode. While this may appear to be a weakness, since less information is being used, we find in", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 298, + 349, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 349, + 310 + ], + "score": 1.0, + "content": "practice that it seems to lead to more stable training profiles.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 12.5, + "bbox_fs": [ + 105, + 199, + 506, + 310 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 314, + 505, + 381 + ], + "lines": [ + { + "bbox": [ + 106, + 314, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 314, + 506, + 327 + ], + "score": 1.0, + "content": "This paper is organized as follows. In Section 2, we give a formal definition of MAML, and discuss", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 325, + 504, + 337 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 504, + 337 + ], + "score": 1.0, + "content": "related works. In Section 3, we introduce Evolutionary Strategies and show how ES can be applied", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 335, + 505, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 505, + 350 + ], + "score": 1.0, + "content": "to create a new framework for MAML. In Section 4, we present numerical experiments, highlighting", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 347, + 505, + 360 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 505, + 360 + ], + "score": 1.0, + "content": "the topics of exploration (Section 4.1), the utility of compact architectures (Section 4.2), the stability", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 358, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 505, + 371 + ], + "score": 1.0, + "content": "of deterministic policies (Section 4.3), and comparisons against existing MAML algorithms in the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 369, + 434, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 369, + 434, + 382 + ], + "score": 1.0, + "content": "few-shot regime (Section 4.4). Additional material can be found in the Appendix.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20.5, + "bbox_fs": [ + 105, + 314, + 506, + 382 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 398, + 348, + 412 + ], + "lines": [ + { + "bbox": [ + 105, + 398, + 349, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 349, + 413 + ], + "score": 1.0, + "content": "2 MODEL AGNOSTIC META LEARNING IN RL", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 425, + 505, + 514 + ], + "lines": [ + { + "bbox": [ + 106, + 425, + 505, + 438 + ], + "spans": [ + { + "bbox": [ + 106, + 425, + 424, + 438 + ], + "score": 1.0, + "content": "We first discuss the original formulation of MAML (Finn et al., 2017). Let", + "type": "text" + }, + { + "bbox": [ + 424, + 426, + 434, + 436 + ], + "score": 0.82, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 425, + 505, + 438 + ], + "score": 1.0, + "content": "be a set of rein-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 436, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 436, + 361, + 448 + ], + "score": 1.0, + "content": "forcement learning tasks with common state and action spaces", + "type": "text" + }, + { + "bbox": [ + 361, + 437, + 381, + 448 + ], + "score": 0.88, + "content": "s , A", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 436, + 403, + 448 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 403, + 437, + 427, + 448 + ], + "score": 0.92, + "content": "\\mathcal { P } ( \\mathcal { T } )", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 436, + 505, + 448 + ], + "score": 1.0, + "content": "a distribution over", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 107, + 446, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 107, + 448, + 116, + 458 + ], + "score": 0.8, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 116, + 446, + 291, + 460 + ], + "score": 1.0, + "content": ". In the standard MAML setting, each task", + "type": "text" + }, + { + "bbox": [ + 292, + 448, + 325, + 459 + ], + "score": 0.92, + "content": "T _ { i } \\in \\mathcal { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 446, + 505, + 460 + ], + "score": 1.0, + "content": "has an associated Markov Decision Process", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 458, + 503, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 246, + 472 + ], + "score": 1.0, + "content": "(MDP) with transition distribution", + "type": "text" + }, + { + "bbox": [ + 247, + 459, + 306, + 470 + ], + "score": 0.92, + "content": "q _ { i } ( s _ { t + 1 } | s _ { t } , a _ { t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 458, + 382, + 472 + ], + "score": 1.0, + "content": ", an episode length", + "type": "text" + }, + { + "bbox": [ + 382, + 459, + 393, + 469 + ], + "score": 0.81, + "content": "H", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 458, + 487, + 472 + ], + "score": 1.0, + "content": ", and a reward function", + "type": "text" + }, + { + "bbox": [ + 487, + 459, + 503, + 470 + ], + "score": 0.89, + "content": "R _ { T _ { i } }", + "type": "inline_equation" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 469, + 506, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 205, + 483 + ], + "score": 1.0, + "content": "which maps a trajectory", + "type": "text" + }, + { + "bbox": [ + 205, + 470, + 313, + 482 + ], + "score": 0.88, + "content": "\\tau = ( s _ { 0 } , a _ { 1 } , . . . , a _ { H - 1 } , s _ { H } )", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 469, + 390, + 483 + ], + "score": 1.0, + "content": "to the total reward", + "type": "text" + }, + { + "bbox": [ + 390, + 469, + 412, + 482 + ], + "score": 0.92, + "content": "R ( \\tau )", + "type": "inline_equation" + }, + { + "bbox": [ + 412, + 469, + 506, + 483 + ], + "score": 1.0, + "content": ". A stochastic policy is", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 479, + 506, + 493 + ], + "spans": [ + { + "bbox": [ + 104, + 479, + 150, + 493 + ], + "score": 1.0, + "content": "a function", + "type": "text" + }, + { + "bbox": [ + 150, + 480, + 215, + 492 + ], + "score": 0.93, + "content": "\\pi : { \\mathcal { S } } { \\mathcal { P } } ( { \\mathcal { A } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 215, + 479, + 506, + 493 + ], + "score": 1.0, + "content": "which maps states to probability distributions over the action space. A", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 491, + 506, + 504 + ], + "spans": [ + { + "bbox": [ + 106, + 491, + 242, + 504 + ], + "score": 1.0, + "content": "deterministic policy is a function", + "type": "text" + }, + { + "bbox": [ + 242, + 492, + 292, + 502 + ], + "score": 0.9, + "content": "\\pi : { \\mathcal { S } } A", + "type": "inline_equation" + }, + { + "bbox": [ + 292, + 491, + 506, + 504 + ], + "score": 1.0, + "content": ". Policies are typically encoded by a neural network", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 503, + 375, + 515 + ], + "spans": [ + { + "bbox": [ + 106, + 503, + 173, + 515 + ], + "score": 1.0, + "content": "with parameters", + "type": "text" + }, + { + "bbox": [ + 173, + 503, + 179, + 512 + ], + "score": 0.76, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 180, + 503, + 310, + 515 + ], + "score": 1.0, + "content": ", and we often refer to the policy", + "type": "text" + }, + { + "bbox": [ + 310, + 504, + 322, + 514 + ], + "score": 0.86, + "content": "\\pi _ { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 503, + 365, + 515 + ], + "score": 1.0, + "content": "simply by", + "type": "text" + }, + { + "bbox": [ + 365, + 503, + 371, + 512 + ], + "score": 0.81, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 371, + 503, + 375, + 515 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 28.5, + "bbox_fs": [ + 104, + 425, + 506, + 515 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 519, + 505, + 563 + ], + "lines": [ + { + "bbox": [ + 106, + 519, + 506, + 531 + ], + "spans": [ + { + "bbox": [ + 106, + 519, + 506, + 531 + ], + "score": 1.0, + "content": "The MAML problem is to find the so-called MAML point (called also a meta-policy), which is a", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 529, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 133, + 543 + ], + "score": 1.0, + "content": "policy", + "type": "text" + }, + { + "bbox": [ + 134, + 530, + 145, + 540 + ], + "score": 0.84, + "content": "\\theta ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 529, + 371, + 543 + ], + "score": 1.0, + "content": "that can be ‘adapted’ quickly to solve an unknown task", + "type": "text" + }, + { + "bbox": [ + 371, + 531, + 401, + 541 + ], + "score": 0.87, + "content": "T \\in { \\mathcal { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 529, + 505, + 543 + ], + "score": 1.0, + "content": "by taking a (few)1 policy", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 541, + 506, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 226, + 554 + ], + "score": 1.0, + "content": "gradient steps with respect to", + "type": "text" + }, + { + "bbox": [ + 226, + 542, + 235, + 551 + ], + "score": 0.81, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 541, + 506, + 554 + ], + "score": 1.0, + "content": ". The optimization problem to be solved in training (in its one-shot", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 552, + 220, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 220, + 564 + ], + "score": 1.0, + "content": "version) is thus of the form:", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 519, + 506, + 564 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 208, + 570, + 403, + 589 + ], + "lines": [ + { + "bbox": [ + 208, + 570, + 403, + 589 + ], + "spans": [ + { + "bbox": [ + 208, + 570, + 403, + 589 + ], + "score": 0.89, + "content": "\\operatorname* { m a x } _ { \\theta } J ( \\theta ) : = \\mathbb { E } _ { T \\sim \\mathcal { P } ( \\mathcal { T } ) } [ \\mathbb { E } _ { \\tau ^ { \\prime } \\sim \\mathcal { P } _ { \\mathcal { T } } ( \\tau ^ { \\prime } \\mid \\theta ^ { \\prime } ) } [ R _ { T } ( \\tau ^ { \\prime } ) ] ] ,", + "type": "interline_equation", + "image_path": "5cf6926b28dbbb6bd07c6286c152dc3cb1f64db003ca22f8c12948c2473f51bd.jpg" + } + ] + } + ], + "index": 37, + "virtual_lines": [ + { + "bbox": [ + 208, + 570, + 403, + 589 + ], + "spans": [], + "index": 37 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 596, + 505, + 632 + ], + "lines": [ + { + "bbox": [ + 105, + 595, + 506, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 137, + 612 + ], + "score": 1.0, + "content": "where:", + "type": "text" + }, + { + "bbox": [ + 138, + 597, + 328, + 610 + ], + "score": 0.91, + "content": "\\theta ^ { \\prime } = U ( \\theta , T ) = \\theta + \\alpha \\nabla _ { \\theta } \\mathbb { E } _ { \\tau \\sim \\mathcal { P } _ { T } ( \\tau | \\theta ) } [ R _ { T } ( \\tau ) ]", + "type": "inline_equation" + }, + { + "bbox": [ + 328, + 595, + 506, + 612 + ], + "score": 1.0, + "content": "is called the adapted policy for a step size", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 107, + 607, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 107, + 609, + 133, + 619 + ], + "score": 0.88, + "content": "\\alpha > 0", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 607, + 150, + 622 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 150, + 609, + 183, + 621 + ], + "score": 0.92, + "content": "\\mathcal { P } _ { T } ( \\cdot | \\eta )", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 607, + 356, + 622 + ], + "score": 1.0, + "content": "is a distribution over trajectories given task", + "type": "text" + }, + { + "bbox": [ + 356, + 609, + 384, + 619 + ], + "score": 0.9, + "content": "T \\in { \\mathcal { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 607, + 505, + 622 + ], + "score": 1.0, + "content": "and conditioned on the policy", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 619, + 189, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 178, + 634 + ], + "score": 1.0, + "content": "parameterized by", + "type": "text" + }, + { + "bbox": [ + 178, + 623, + 184, + 632 + ], + "score": 0.8, + "content": "\\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 619, + 189, + 634 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39, + "bbox_fs": [ + 105, + 595, + 506, + 634 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 636, + 504, + 659 + ], + "lines": [ + { + "bbox": [ + 106, + 636, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 636, + 505, + 649 + ], + "score": 1.0, + "content": "Standard MAML approaches are based on the following expression for the gradient of the MAML", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 647, + 275, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 647, + 275, + 661 + ], + "score": 1.0, + "content": "objective function (1) to conduct training:", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5, + "bbox_fs": [ + 106, + 636, + 505, + 661 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 155, + 666, + 455, + 681 + ], + "lines": [ + { + "bbox": [ + 155, + 666, + 455, + 681 + ], + "spans": [ + { + "bbox": [ + 155, + 666, + 455, + 681 + ], + "score": 0.88, + "content": "\\nabla _ { \\theta } J ( \\theta ) = \\mathbb { E } _ { T \\sim \\mathcal { P } ( \\mathcal { T } ) } [ \\mathbb { E } _ { r ^ { \\prime } \\sim \\mathcal { P } _ { T } ( \\tau ^ { \\prime } \\mid \\theta ^ { \\prime } ) } [ \\nabla _ { \\theta ^ { \\prime } } \\log \\mathcal { P } _ { T } ( \\tau ^ { \\prime } \\mid \\theta ^ { \\prime } ) R _ { T } ( \\tau ^ { \\prime } ) \\nabla _ { \\theta } U ( \\theta , T ) ] ] .", + "type": "interline_equation", + "image_path": "e19859288a13398f9e7a59655f53033778ab61b784dd0fe7f9fe408ecdd33d85.jpg" + } + ] + } + ], + "index": 43, + "virtual_lines": [ + { + "bbox": [ + 155, + 666, + 455, + 681 + ], + "spans": [], + "index": 43 + } + ] + }, + { + "type": "text", + "bbox": [ + 110, + 687, + 494, + 700 + ], + "lines": [ + { + "bbox": [ + 108, + 686, + 495, + 702 + ], + "spans": [ + { + "bbox": [ + 108, + 686, + 495, + 702 + ], + "score": 1.0, + "content": "We collectively refer to algorithms based on computing (2) using policy gradients as PG-MAML.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 44, + "bbox_fs": [ + 108, + 686, + 495, + 702 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 81, + 505, + 106 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 229, + 97 + ], + "score": 1.0, + "content": "Since the adaptation operator", + "type": "text" + }, + { + "bbox": [ + 230, + 82, + 262, + 95 + ], + "score": 0.93, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 81, + 381, + 97 + ], + "score": 1.0, + "content": "contains the policy gradient", + "type": "text" + }, + { + "bbox": [ + 382, + 82, + 468, + 96 + ], + "score": 0.93, + "content": "\\nabla _ { \\boldsymbol { \\theta } } \\mathbb { E } _ { \\tau \\sim \\mathcal { P } _ { T } ( \\tau \\mid \\boldsymbol { \\theta } ) } [ R ( \\tau ) ]", + "type": "inline_equation" + }, + { + "bbox": [ + 468, + 81, + 505, + 97 + ], + "score": 1.0, + "content": ", its own", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 273, + 107 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 142, + 107 + ], + "score": 1.0, + "content": "gradient", + "type": "text" + }, + { + "bbox": [ + 142, + 94, + 187, + 106 + ], + "score": 0.94, + "content": "\\nabla _ { \\boldsymbol { \\theta } } U ( \\boldsymbol { \\theta } , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 94, + 263, + 107 + ], + "score": 1.0, + "content": "is second-order in", + "type": "text" + }, + { + "bbox": [ + 263, + 95, + 269, + 104 + ], + "score": 0.79, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 94, + 273, + 107 + ], + "score": 1.0, + "content": ":", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "interline_equation", + "bbox": [ + 111, + 110, + 512, + 136 + ], + "lines": [ + { + "bbox": [ + 111, + 110, + 512, + 136 + ], + "spans": [ + { + "bbox": [ + 111, + 110, + 512, + 136 + ], + "score": 0.92, + "content": "\\mathcal { I } _ { \\theta } U = \\mathbf { I } + \\alpha \\int \\mathcal { P } _ { T } ( \\tau | \\theta ) \\nabla _ { \\theta } ^ { 2 } \\log \\pi _ { \\theta } ( \\tau ) R _ { T } ( \\tau ) d \\tau + \\alpha \\int \\mathcal { P } _ { T } ( \\tau | \\theta ) \\nabla _ { \\theta } \\log \\pi _ { \\theta } ( \\tau ) \\nabla _ { \\theta } \\log \\pi _ { \\theta } ( \\tau ) ^ { T } R _ { T } ( \\tau ) d \\tau .", + "type": "interline_equation", + "image_path": "3f138a7778e4681c1dceaac95420db32e3e1fc4a039384b057bd1b6f37b3e745.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 111, + 110, + 512, + 136 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 144, + 505, + 266 + ], + "lines": [ + { + "bbox": [ + 106, + 145, + 505, + 157 + ], + "spans": [ + { + "bbox": [ + 106, + 145, + 505, + 157 + ], + "score": 1.0, + "content": "Correctly computing the gradient (2) with the term (3) using automatic differentiation is known to", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 156, + 505, + 168 + ], + "spans": [ + { + "bbox": [ + 105, + 156, + 505, + 168 + ], + "score": 1.0, + "content": "be tricky. Multiple authors (Foerster et al., 2018; Rothfuss et al., 2019; Liu et al., 2019) have pointed", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 167, + 505, + 179 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 505, + 179 + ], + "score": 1.0, + "content": "out that the original implementation of MAML incorrectly estimates the term (3), which inadver-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 178, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 178, + 505, + 190 + ], + "score": 1.0, + "content": "tently causes the training to lose ‘pre-adaptation credit assignment’. Moreover, even when correctly", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 189, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 106, + 189, + 505, + 201 + ], + "score": 1.0, + "content": "implemented, the variance when estimating (3) can be extremely high, which impedes training. To", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 200, + 506, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 200, + 506, + 212 + ], + "score": 1.0, + "content": "improve on this, extensions to the original MAML include ProMP (Rothfuss et al., 2019), which", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 211, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 211, + 505, + 222 + ], + "score": 1.0, + "content": "introduces a new low-variance curvature (LVC) estimator for the Hessian, and T-MAML (Liu et al.,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 221, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 505, + 234 + ], + "score": 1.0, + "content": "2019), which adds control variates to reduce the variance of the unbiased DiCE estimator (Foerster", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 232, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 505, + 245 + ], + "score": 1.0, + "content": "et al., 2018). However, these are not without their drawbacks: the proposed solutions are com-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 244, + 504, + 255 + ], + "spans": [ + { + "bbox": [ + 106, + 244, + 504, + 255 + ], + "score": 1.0, + "content": "plicated, the variance of the Hessian estimate remains problematic, and LVC introduces unknown", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 254, + 167, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 167, + 266 + ], + "score": 1.0, + "content": "estimator bias.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 271, + 505, + 316 + ], + "lines": [ + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "score": 1.0, + "content": "Another issue that arises in PG-MAML is that policies are necessarily stochastic. However, ran-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "score": 1.0, + "content": "domized actions can lead to risky exploration behavior when computing the adaptation, especially", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 293, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 505, + 306 + ], + "score": 1.0, + "content": "for robotics applications where the collection of tasks may involve differing system dynamics as", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 304, + 477, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 477, + 316 + ], + "score": 1.0, + "content": "opposed to only differing rewards (Yang et al., 2019). We explore this further in Section 4.3.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 108, + 321, + 502, + 354 + ], + "lines": [ + { + "bbox": [ + 105, + 319, + 504, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 319, + 470, + 335 + ], + "score": 1.0, + "content": "These issues: the difficulty of estimating the Hessian term (3), the typically high variance of", + "type": "text" + }, + { + "bbox": [ + 471, + 321, + 504, + 333 + ], + "score": 0.92, + "content": "\\nabla _ { \\boldsymbol { \\theta } } J ( \\boldsymbol { \\theta } )", + "type": "inline_equation" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 332, + 504, + 344 + ], + "spans": [ + { + "bbox": [ + 106, + 332, + 504, + 344 + ], + "score": 1.0, + "content": "for policy gradient algorithms in general, and the unsuitability of stochastic policies in some do-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 343, + 363, + 355 + ], + "spans": [ + { + "bbox": [ + 106, + 343, + 363, + 355 + ], + "score": 1.0, + "content": "mains, lead us to the proposed method ES-MAML in Section 3.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 106, + 360, + 505, + 437 + ], + "lines": [ + { + "bbox": [ + 106, + 360, + 505, + 372 + ], + "spans": [ + { + "bbox": [ + 106, + 360, + 505, + 372 + ], + "score": 1.0, + "content": "Aside from policy gradients, there have also been biologically-inspired algorithms for MAML, based", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 371, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 505, + 383 + ], + "score": 1.0, + "content": "on concepts such as the Baldwin effect (Fernando et al., 2018). However, we note that despite the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 382, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 382, + 505, + 394 + ], + "score": 1.0, + "content": "similar naming, methods such as ‘Evolvability ES’ (Gajewski et al., 2019) bear little resemblance", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 393, + 506, + 406 + ], + "spans": [ + { + "bbox": [ + 104, + 393, + 506, + 406 + ], + "score": 1.0, + "content": "to our proposed ES-MAML. The problem solved by our algorithm is the standard MAML, whereas", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "score": 1.0, + "content": "(Gajewski et al., 2019) aims to maximize loosely related notions of the diversity of behavioral char-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 415, + 506, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 506, + 427 + ], + "score": 1.0, + "content": "acteristics. Moreover, ES-MAML and its extensions we consider are all derived notions such as", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 426, + 460, + 438 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 460, + 438 + ], + "score": 1.0, + "content": "smoothings and approximations, with rigorous mathematical definitions as stated below.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24 + }, + { + "type": "title", + "bbox": [ + 108, + 452, + 258, + 466 + ], + "lines": [ + { + "bbox": [ + 105, + 451, + 261, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 261, + 468 + ], + "score": 1.0, + "content": "3 ES-MAML ALGORITHMS", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 108, + 477, + 504, + 511 + ], + "lines": [ + { + "bbox": [ + 105, + 477, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 505, + 491 + ], + "score": 1.0, + "content": "Formulating MAML with ES allows us to employ numerous techniques originally developed for", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 488, + 505, + 503 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 505, + 503 + ], + "score": 1.0, + "content": "enhancing ES, to MAML. We aim to improve both phases of MAML algorithm: the meta-learning", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 500, + 363, + 513 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 363, + 513 + ], + "score": 1.0, + "content": "training algorithm, and the efficiency of the adaptation operator.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30 + }, + { + "type": "title", + "bbox": [ + 107, + 524, + 308, + 536 + ], + "lines": [ + { + "bbox": [ + 105, + 522, + 309, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 309, + 538 + ], + "score": 1.0, + "content": "3.1 EVOLUTION STRATEGIES METHODS (ES)", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 106, + 544, + 505, + 624 + ], + "lines": [ + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "score": 1.0, + "content": "Evolution Strategies (ES) (Wierstra et al., 2008; 2014), which recently became popular for RL (Sal-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 555, + 506, + 569 + ], + "spans": [ + { + "bbox": [ + 104, + 555, + 441, + 569 + ], + "score": 1.0, + "content": "imans et al., 2017), rely on optimizing the smoothing of the blackbox function", + "type": "text" + }, + { + "bbox": [ + 441, + 556, + 501, + 568 + ], + "score": 0.9, + "content": "f : \\mathbb { R } ^ { d } \\mathbb { R }", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 555, + 506, + 569 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 565, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 239, + 581 + ], + "score": 1.0, + "content": "which takes as input parameters", + "type": "text" + }, + { + "bbox": [ + 240, + 567, + 272, + 577 + ], + "score": 0.92, + "content": "\\theta \\in { \\mathbb { R } } ^ { d }", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 565, + 505, + 581 + ], + "score": 1.0, + "content": "of the policy and outputs total discounted (expected) re-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 578, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 106, + 578, + 505, + 591 + ], + "score": 1.0, + "content": "ward obtained by an agent applying that policy in the given environment. Instead of optimizing the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 588, + 504, + 602 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 143, + 602 + ], + "score": 1.0, + "content": "function", + "type": "text" + }, + { + "bbox": [ + 143, + 590, + 151, + 600 + ], + "score": 0.81, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 588, + 495, + 602 + ], + "score": 1.0, + "content": "directly, we optimize a smoothed objective. We define the Gaussian smoothing of", + "type": "text" + }, + { + "bbox": [ + 495, + 590, + 504, + 599 + ], + "score": 0.81, + "content": "F", + "type": "inline_equation" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 599, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 104, + 599, + 118, + 617 + ], + "score": 1.0, + "content": "as", + "type": "text" + }, + { + "bbox": [ + 118, + 600, + 250, + 614 + ], + "score": 0.93, + "content": "\\tilde { f } _ { \\sigma } ( \\theta ) = \\mathbb { E } _ { \\mathbf { g } \\sim \\mathcal { N } ( 0 , \\mathbb { I } _ { d } ) } [ f ( \\theta + \\sigma \\mathbf { g } ) ]", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 599, + 506, + 617 + ], + "score": 1.0, + "content": ". The gradient of this smoothed objective, sometimes called an", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 612, + 353, + 626 + ], + "spans": [ + { + "bbox": [ + 106, + 613, + 119, + 623 + ], + "score": 0.65, + "content": "E S", + "type": "inline_equation" + }, + { + "bbox": [ + 119, + 612, + 353, + 626 + ], + "score": 1.0, + "content": "-gradient, is given as (see: (Nesterov & Spokoiny, 2017)):", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36 + }, + { + "type": "interline_equation", + "bbox": [ + 224, + 628, + 387, + 651 + ], + "lines": [ + { + "bbox": [ + 224, + 628, + 387, + 651 + ], + "spans": [ + { + "bbox": [ + 224, + 628, + 387, + 651 + ], + "score": 0.95, + "content": "\\nabla _ { \\boldsymbol { \\theta } } \\tilde { f } _ { \\sigma } ( \\boldsymbol { \\theta } ) = \\frac { 1 } { \\sigma } \\mathbb { E } _ { \\mathbf { g } \\sim \\mathcal { N } ( 0 , \\mathbf { I } _ { d } ) } [ f ( \\boldsymbol { \\theta } + \\sigma \\mathbf { g } ) \\mathbf { g } ] .", + "type": "interline_equation", + "image_path": "5f2b07875c8775a1f31637aaa3c758e75e4ebf7038d41f8745cb23415014bfc2.jpg" + } + ] + } + ], + "index": 40, + "virtual_lines": [ + { + "bbox": [ + 224, + 628, + 387, + 651 + ], + "spans": [], + "index": 40 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 655, + 409, + 667 + ], + "lines": [ + { + "bbox": [ + 105, + 653, + 411, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 411, + 669 + ], + "score": 1.0, + "content": "Note that the gradient can be approximated via Monte Carlo (MC) samples:", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 106, + 672, + 505, + 733 + ], + "lines": [ + { + "bbox": [ + 106, + 672, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 106, + 672, + 505, + 684 + ], + "score": 1.0, + "content": "In ES literature the above algorithm is often modified by adding control variates to equation 4 to", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 682, + 505, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 486, + 695 + ], + "score": 1.0, + "content": "obtain other unbiased estimators with reduced variance. The forward finite difference (Forward-", + "type": "text" + }, + { + "bbox": [ + 486, + 684, + 501, + 694 + ], + "score": 0.39, + "content": "F D", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 682, + 505, + 695 + ], + "score": 1.0, + "content": ")", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 693, + 505, + 707 + ], + "spans": [ + { + "bbox": [ + 106, + 693, + 446, + 707 + ], + "score": 1.0, + "content": "estimator (Choromanski et al., 2018) is given by subtracting the current policy value", + "type": "text" + }, + { + "bbox": [ + 446, + 694, + 466, + 706 + ], + "score": 0.91, + "content": "f ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 693, + 505, + 707 + ], + "score": 1.0, + "content": ", yielding", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 705, + 506, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 705, + 306, + 720 + ], + "score": 0.87, + "content": "\\begin{array} { r } { \\nabla _ { \\boldsymbol { \\theta } } \\tilde { f } _ { \\sigma } ( \\boldsymbol { \\theta } ) = \\frac { 1 } { \\sigma } \\mathbb { E } _ { \\mathbf { g } \\sim \\mathcal { N } ( 0 , \\mathbf { I } _ { d } ) } [ ( f ( \\boldsymbol { \\theta } + \\sigma \\mathbf { g } ) - f ( \\boldsymbol { \\theta } ) ) \\mathbf { g } ] } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 705, + 506, + 721 + ], + "score": 1.0, + "content": ". The antithetic estimator (Nesterov & Spokoiny,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 718, + 505, + 735 + ], + "spans": [ + { + "bbox": [ + 105, + 718, + 363, + 735 + ], + "score": 1.0, + "content": "2017; Mania et al., 2018) is given by the symmetric difference", + "type": "text" + }, + { + "bbox": [ + 363, + 718, + 505, + 734 + ], + "score": 0.92, + "content": "\\begin{array} { r } { \\nabla _ { \\theta } \\tilde { f } _ { \\sigma } ( \\theta ) = \\frac { 1 } { 2 \\sigma } \\mathbb { E } _ { \\mathbf { g } \\sim \\mathcal { N } ( 0 , \\mathbf { I } _ { d } ) } [ ( f ( \\theta + } \\end{array}", + "type": "inline_equation" + } + ], + "index": 46 + } + ], + "index": 44 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 81, + 505, + 106 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 229, + 97 + ], + "score": 1.0, + "content": "Since the adaptation operator", + "type": "text" + }, + { + "bbox": [ + 230, + 82, + 262, + 95 + ], + "score": 0.93, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 81, + 381, + 97 + ], + "score": 1.0, + "content": "contains the policy gradient", + "type": "text" + }, + { + "bbox": [ + 382, + 82, + 468, + 96 + ], + "score": 0.93, + "content": "\\nabla _ { \\boldsymbol { \\theta } } \\mathbb { E } _ { \\tau \\sim \\mathcal { P } _ { T } ( \\tau \\mid \\boldsymbol { \\theta } ) } [ R ( \\tau ) ]", + "type": "inline_equation" + }, + { + "bbox": [ + 468, + 81, + 505, + 97 + ], + "score": 1.0, + "content": ", its own", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 273, + 107 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 142, + 107 + ], + "score": 1.0, + "content": "gradient", + "type": "text" + }, + { + "bbox": [ + 142, + 94, + 187, + 106 + ], + "score": 0.94, + "content": "\\nabla _ { \\boldsymbol { \\theta } } U ( \\boldsymbol { \\theta } , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 94, + 263, + 107 + ], + "score": 1.0, + "content": "is second-order in", + "type": "text" + }, + { + "bbox": [ + 263, + 95, + 269, + 104 + ], + "score": 0.79, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 94, + 273, + 107 + ], + "score": 1.0, + "content": ":", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 105, + 81, + 505, + 107 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 111, + 110, + 512, + 136 + ], + "lines": [ + { + "bbox": [ + 111, + 110, + 512, + 136 + ], + "spans": [ + { + "bbox": [ + 111, + 110, + 512, + 136 + ], + "score": 0.92, + "content": "\\mathcal { I } _ { \\theta } U = \\mathbf { I } + \\alpha \\int \\mathcal { P } _ { T } ( \\tau | \\theta ) \\nabla _ { \\theta } ^ { 2 } \\log \\pi _ { \\theta } ( \\tau ) R _ { T } ( \\tau ) d \\tau + \\alpha \\int \\mathcal { P } _ { T } ( \\tau | \\theta ) \\nabla _ { \\theta } \\log \\pi _ { \\theta } ( \\tau ) \\nabla _ { \\theta } \\log \\pi _ { \\theta } ( \\tau ) ^ { T } R _ { T } ( \\tau ) d \\tau .", + "type": "interline_equation", + "image_path": "3f138a7778e4681c1dceaac95420db32e3e1fc4a039384b057bd1b6f37b3e745.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 111, + 110, + 512, + 136 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 144, + 505, + 266 + ], + "lines": [ + { + "bbox": [ + 106, + 145, + 505, + 157 + ], + "spans": [ + { + "bbox": [ + 106, + 145, + 505, + 157 + ], + "score": 1.0, + "content": "Correctly computing the gradient (2) with the term (3) using automatic differentiation is known to", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 156, + 505, + 168 + ], + "spans": [ + { + "bbox": [ + 105, + 156, + 505, + 168 + ], + "score": 1.0, + "content": "be tricky. Multiple authors (Foerster et al., 2018; Rothfuss et al., 2019; Liu et al., 2019) have pointed", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 167, + 505, + 179 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 505, + 179 + ], + "score": 1.0, + "content": "out that the original implementation of MAML incorrectly estimates the term (3), which inadver-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 178, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 178, + 505, + 190 + ], + "score": 1.0, + "content": "tently causes the training to lose ‘pre-adaptation credit assignment’. Moreover, even when correctly", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 189, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 106, + 189, + 505, + 201 + ], + "score": 1.0, + "content": "implemented, the variance when estimating (3) can be extremely high, which impedes training. To", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 200, + 506, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 200, + 506, + 212 + ], + "score": 1.0, + "content": "improve on this, extensions to the original MAML include ProMP (Rothfuss et al., 2019), which", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 211, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 211, + 505, + 222 + ], + "score": 1.0, + "content": "introduces a new low-variance curvature (LVC) estimator for the Hessian, and T-MAML (Liu et al.,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 221, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 505, + 234 + ], + "score": 1.0, + "content": "2019), which adds control variates to reduce the variance of the unbiased DiCE estimator (Foerster", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 232, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 505, + 245 + ], + "score": 1.0, + "content": "et al., 2018). However, these are not without their drawbacks: the proposed solutions are com-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 244, + 504, + 255 + ], + "spans": [ + { + "bbox": [ + 106, + 244, + 504, + 255 + ], + "score": 1.0, + "content": "plicated, the variance of the Hessian estimate remains problematic, and LVC introduces unknown", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 254, + 167, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 167, + 266 + ], + "score": 1.0, + "content": "estimator bias.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 145, + 506, + 266 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 271, + 505, + 316 + ], + "lines": [ + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "score": 1.0, + "content": "Another issue that arises in PG-MAML is that policies are necessarily stochastic. However, ran-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "score": 1.0, + "content": "domized actions can lead to risky exploration behavior when computing the adaptation, especially", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 293, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 505, + 306 + ], + "score": 1.0, + "content": "for robotics applications where the collection of tasks may involve differing system dynamics as", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 304, + 477, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 477, + 316 + ], + "score": 1.0, + "content": "opposed to only differing rewards (Yang et al., 2019). We explore this further in Section 4.3.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 271, + 505, + 316 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 321, + 502, + 354 + ], + "lines": [ + { + "bbox": [ + 105, + 319, + 504, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 319, + 470, + 335 + ], + "score": 1.0, + "content": "These issues: the difficulty of estimating the Hessian term (3), the typically high variance of", + "type": "text" + }, + { + "bbox": [ + 471, + 321, + 504, + 333 + ], + "score": 0.92, + "content": "\\nabla _ { \\boldsymbol { \\theta } } J ( \\boldsymbol { \\theta } )", + "type": "inline_equation" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 332, + 504, + 344 + ], + "spans": [ + { + "bbox": [ + 106, + 332, + 504, + 344 + ], + "score": 1.0, + "content": "for policy gradient algorithms in general, and the unsuitability of stochastic policies in some do-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 343, + 363, + 355 + ], + "spans": [ + { + "bbox": [ + 106, + 343, + 363, + 355 + ], + "score": 1.0, + "content": "mains, lead us to the proposed method ES-MAML in Section 3.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19, + "bbox_fs": [ + 105, + 319, + 504, + 355 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 360, + 505, + 437 + ], + "lines": [ + { + "bbox": [ + 106, + 360, + 505, + 372 + ], + "spans": [ + { + "bbox": [ + 106, + 360, + 505, + 372 + ], + "score": 1.0, + "content": "Aside from policy gradients, there have also been biologically-inspired algorithms for MAML, based", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 371, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 505, + 383 + ], + "score": 1.0, + "content": "on concepts such as the Baldwin effect (Fernando et al., 2018). However, we note that despite the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 382, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 382, + 505, + 394 + ], + "score": 1.0, + "content": "similar naming, methods such as ‘Evolvability ES’ (Gajewski et al., 2019) bear little resemblance", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 393, + 506, + 406 + ], + "spans": [ + { + "bbox": [ + 104, + 393, + 506, + 406 + ], + "score": 1.0, + "content": "to our proposed ES-MAML. The problem solved by our algorithm is the standard MAML, whereas", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "score": 1.0, + "content": "(Gajewski et al., 2019) aims to maximize loosely related notions of the diversity of behavioral char-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 415, + 506, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 506, + 427 + ], + "score": 1.0, + "content": "acteristics. Moreover, ES-MAML and its extensions we consider are all derived notions such as", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 426, + 460, + 438 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 460, + 438 + ], + "score": 1.0, + "content": "smoothings and approximations, with rigorous mathematical definitions as stated below.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24, + "bbox_fs": [ + 104, + 360, + 506, + 438 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 452, + 258, + 466 + ], + "lines": [ + { + "bbox": [ + 105, + 451, + 261, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 261, + 468 + ], + "score": 1.0, + "content": "3 ES-MAML ALGORITHMS", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 108, + 477, + 504, + 511 + ], + "lines": [ + { + "bbox": [ + 105, + 477, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 505, + 491 + ], + "score": 1.0, + "content": "Formulating MAML with ES allows us to employ numerous techniques originally developed for", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 488, + 505, + 503 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 505, + 503 + ], + "score": 1.0, + "content": "enhancing ES, to MAML. We aim to improve both phases of MAML algorithm: the meta-learning", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 500, + 363, + 513 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 363, + 513 + ], + "score": 1.0, + "content": "training algorithm, and the efficiency of the adaptation operator.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30, + "bbox_fs": [ + 105, + 477, + 505, + 513 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 524, + 308, + 536 + ], + "lines": [ + { + "bbox": [ + 105, + 522, + 309, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 309, + 538 + ], + "score": 1.0, + "content": "3.1 EVOLUTION STRATEGIES METHODS (ES)", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 106, + 544, + 505, + 624 + ], + "lines": [ + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "score": 1.0, + "content": "Evolution Strategies (ES) (Wierstra et al., 2008; 2014), which recently became popular for RL (Sal-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 555, + 506, + 569 + ], + "spans": [ + { + "bbox": [ + 104, + 555, + 441, + 569 + ], + "score": 1.0, + "content": "imans et al., 2017), rely on optimizing the smoothing of the blackbox function", + "type": "text" + }, + { + "bbox": [ + 441, + 556, + 501, + 568 + ], + "score": 0.9, + "content": "f : \\mathbb { R } ^ { d } \\mathbb { R }", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 555, + 506, + 569 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 565, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 239, + 581 + ], + "score": 1.0, + "content": "which takes as input parameters", + "type": "text" + }, + { + "bbox": [ + 240, + 567, + 272, + 577 + ], + "score": 0.92, + "content": "\\theta \\in { \\mathbb { R } } ^ { d }", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 565, + 505, + 581 + ], + "score": 1.0, + "content": "of the policy and outputs total discounted (expected) re-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 578, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 106, + 578, + 505, + 591 + ], + "score": 1.0, + "content": "ward obtained by an agent applying that policy in the given environment. Instead of optimizing the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 588, + 504, + 602 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 143, + 602 + ], + "score": 1.0, + "content": "function", + "type": "text" + }, + { + "bbox": [ + 143, + 590, + 151, + 600 + ], + "score": 0.81, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 588, + 495, + 602 + ], + "score": 1.0, + "content": "directly, we optimize a smoothed objective. We define the Gaussian smoothing of", + "type": "text" + }, + { + "bbox": [ + 495, + 590, + 504, + 599 + ], + "score": 0.81, + "content": "F", + "type": "inline_equation" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 599, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 104, + 599, + 118, + 617 + ], + "score": 1.0, + "content": "as", + "type": "text" + }, + { + "bbox": [ + 118, + 600, + 250, + 614 + ], + "score": 0.93, + "content": "\\tilde { f } _ { \\sigma } ( \\theta ) = \\mathbb { E } _ { \\mathbf { g } \\sim \\mathcal { N } ( 0 , \\mathbb { I } _ { d } ) } [ f ( \\theta + \\sigma \\mathbf { g } ) ]", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 599, + 506, + 617 + ], + "score": 1.0, + "content": ". The gradient of this smoothed objective, sometimes called an", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 612, + 353, + 626 + ], + "spans": [ + { + "bbox": [ + 106, + 613, + 119, + 623 + ], + "score": 0.65, + "content": "E S", + "type": "inline_equation" + }, + { + "bbox": [ + 119, + 612, + 353, + 626 + ], + "score": 1.0, + "content": "-gradient, is given as (see: (Nesterov & Spokoiny, 2017)):", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36, + "bbox_fs": [ + 104, + 545, + 506, + 626 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 224, + 628, + 387, + 651 + ], + "lines": [ + { + "bbox": [ + 224, + 628, + 387, + 651 + ], + "spans": [ + { + "bbox": [ + 224, + 628, + 387, + 651 + ], + "score": 0.95, + "content": "\\nabla _ { \\boldsymbol { \\theta } } \\tilde { f } _ { \\sigma } ( \\boldsymbol { \\theta } ) = \\frac { 1 } { \\sigma } \\mathbb { E } _ { \\mathbf { g } \\sim \\mathcal { N } ( 0 , \\mathbf { I } _ { d } ) } [ f ( \\boldsymbol { \\theta } + \\sigma \\mathbf { g } ) \\mathbf { g } ] .", + "type": "interline_equation", + "image_path": "5f2b07875c8775a1f31637aaa3c758e75e4ebf7038d41f8745cb23415014bfc2.jpg" + } + ] + } + ], + "index": 40, + "virtual_lines": [ + { + "bbox": [ + 224, + 628, + 387, + 651 + ], + "spans": [], + "index": 40 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 655, + 409, + 667 + ], + "lines": [ + { + "bbox": [ + 105, + 653, + 411, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 411, + 669 + ], + "score": 1.0, + "content": "Note that the gradient can be approximated via Monte Carlo (MC) samples:", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41, + "bbox_fs": [ + 105, + 653, + 411, + 669 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 672, + 505, + 733 + ], + "lines": [ + { + "bbox": [ + 106, + 672, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 106, + 672, + 505, + 684 + ], + "score": 1.0, + "content": "In ES literature the above algorithm is often modified by adding control variates to equation 4 to", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 682, + 505, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 486, + 695 + ], + "score": 1.0, + "content": "obtain other unbiased estimators with reduced variance. The forward finite difference (Forward-", + "type": "text" + }, + { + "bbox": [ + 486, + 684, + 501, + 694 + ], + "score": 0.39, + "content": "F D", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 682, + 505, + 695 + ], + "score": 1.0, + "content": ")", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 693, + 505, + 707 + ], + "spans": [ + { + "bbox": [ + 106, + 693, + 446, + 707 + ], + "score": 1.0, + "content": "estimator (Choromanski et al., 2018) is given by subtracting the current policy value", + "type": "text" + }, + { + "bbox": [ + 446, + 694, + 466, + 706 + ], + "score": 0.91, + "content": "f ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 693, + 505, + 707 + ], + "score": 1.0, + "content": ", yielding", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 705, + 506, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 705, + 306, + 720 + ], + "score": 0.87, + "content": "\\begin{array} { r } { \\nabla _ { \\boldsymbol { \\theta } } \\tilde { f } _ { \\sigma } ( \\boldsymbol { \\theta } ) = \\frac { 1 } { \\sigma } \\mathbb { E } _ { \\mathbf { g } \\sim \\mathcal { N } ( 0 , \\mathbf { I } _ { d } ) } [ ( f ( \\boldsymbol { \\theta } + \\sigma \\mathbf { g } ) - f ( \\boldsymbol { \\theta } ) ) \\mathbf { g } ] } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 705, + 506, + 721 + ], + "score": 1.0, + "content": ". The antithetic estimator (Nesterov & Spokoiny,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 718, + 505, + 735 + ], + "spans": [ + { + "bbox": [ + 105, + 718, + 363, + 735 + ], + "score": 1.0, + "content": "2017; Mania et al., 2018) is given by the symmetric difference", + "type": "text" + }, + { + "bbox": [ + 363, + 718, + 505, + 734 + ], + "score": 0.92, + "content": "\\begin{array} { r } { \\nabla _ { \\theta } \\tilde { f } _ { \\sigma } ( \\theta ) = \\frac { 1 } { 2 \\sigma } \\mathbb { E } _ { \\mathbf { g } \\sim \\mathcal { N } ( 0 , \\mathbf { I } _ { d } ) } [ ( f ( \\theta + } \\end{array}", + "type": "inline_equation" + } + ], + "index": 46 + } + ], + "index": 44, + "bbox_fs": [ + 105, + 672, + 506, + 735 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 99, + 74, + 189, + 86 + ], + "lines": [ + { + "bbox": [ + 97, + 72, + 188, + 88 + ], + "spans": [ + { + "bbox": [ + 97, + 72, + 144, + 88 + ], + "score": 1.0, + "content": "1 ESGrad", + "type": "text" + }, + { + "bbox": [ + 145, + 74, + 188, + 86 + ], + "score": 0.9, + "content": "( f , \\theta , n , \\sigma )", + "type": "inline_equation" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 96, + 86, + 394, + 121 + ], + "lines": [ + { + "bbox": [ + 122, + 84, + 394, + 97 + ], + "spans": [ + { + "bbox": [ + 122, + 84, + 190, + 97 + ], + "score": 1.0, + "content": "inputs: function", + "type": "text" + }, + { + "bbox": [ + 190, + 86, + 197, + 96 + ], + "score": 0.82, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 84, + 228, + 97 + ], + "score": 1.0, + "content": ", policy", + "type": "text" + }, + { + "bbox": [ + 228, + 86, + 234, + 95 + ], + "score": 0.78, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 84, + 337, + 97 + ], + "score": 1.0, + "content": ", number of perturbations", + "type": "text" + }, + { + "bbox": [ + 337, + 88, + 344, + 95 + ], + "score": 0.69, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 344, + 84, + 387, + 97 + ], + "score": 1.0, + "content": ", precision", + "type": "text" + }, + { + "bbox": [ + 387, + 88, + 394, + 95 + ], + "score": 0.62, + "content": "\\sigma", + "type": "inline_equation" + } + ], + "index": 1 + }, + { + "bbox": [ + 98, + 94, + 293, + 110 + ], + "spans": [ + { + "bbox": [ + 98, + 99, + 104, + 106 + ], + "score": 1.0, + "content": "2", + "type": "text" + }, + { + "bbox": [ + 121, + 94, + 154, + 110 + ], + "score": 1.0, + "content": "Sample", + "type": "text" + }, + { + "bbox": [ + 154, + 97, + 162, + 106 + ], + "score": 0.71, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 94, + 181, + 110 + ], + "score": 1.0, + "content": "i.i.d", + "type": "text" + }, + { + "bbox": [ + 181, + 96, + 213, + 108 + ], + "score": 0.92, + "content": "N ( 0 , I )", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 94, + 245, + 110 + ], + "score": 1.0, + "content": "vectors", + "type": "text" + }, + { + "bbox": [ + 246, + 97, + 288, + 108 + ], + "score": 0.91, + "content": "g _ { 1 } , \\ldots , g _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 94, + 293, + 110 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 97, + 104, + 252, + 124 + ], + "spans": [ + { + "bbox": [ + 97, + 111, + 104, + 119 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 118, + 104, + 152, + 124 + ], + "score": 1.0, + "content": "return", + "type": "text" + }, + { + "bbox": [ + 153, + 108, + 245, + 122 + ], + "score": 0.88, + "content": "\\begin{array} { r } { { \\frac { 1 } { n \\sigma } } \\sum _ { i = 1 } ^ { n } f ( \\theta + \\sigma g _ { i } ) g _ { i } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 104, + 252, + 124 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 225, + 120, + 386, + 132 + ], + "lines": [ + { + "bbox": [ + 224, + 119, + 387, + 132 + ], + "spans": [ + { + "bbox": [ + 224, + 119, + 387, + 132 + ], + "score": 1.0, + "content": "Algorithm 1: Monte Carlo ES Gradient", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 106, + 151, + 505, + 186 + ], + "lines": [ + { + "bbox": [ + 106, + 151, + 506, + 165 + ], + "spans": [ + { + "bbox": [ + 106, + 152, + 196, + 164 + ], + "score": 0.9, + "content": "\\boldsymbol { \\sigma } \\mathbf { g } ) - f ( \\boldsymbol { \\theta } - \\boldsymbol { \\sigma } \\mathbf { g } ) ) \\mathbf { g } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 151, + 506, + 165 + ], + "score": 1.0, + "content": ". Notice that the variance of the Forward-FD and antithetic estimators is", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 163, + 504, + 175 + ], + "spans": [ + { + "bbox": [ + 106, + 163, + 250, + 175 + ], + "score": 1.0, + "content": "translation-invariant with respect to", + "type": "text" + }, + { + "bbox": [ + 250, + 164, + 257, + 175 + ], + "score": 0.83, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 163, + 504, + 175 + ], + "score": 1.0, + "content": ". In practice, the Forward-FD or antithetic estimator is usually", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 174, + 333, + 187 + ], + "spans": [ + { + "bbox": [ + 106, + 174, + 333, + 187 + ], + "score": 1.0, + "content": "preferred over the basic version expressed in equation 4.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 191, + 505, + 236 + ], + "lines": [ + { + "bbox": [ + 105, + 191, + 505, + 204 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 505, + 204 + ], + "score": 1.0, + "content": "In the next sections we will refer to Algorithm 1 for computing the gradient though we emphasize", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 201, + 505, + 215 + ], + "spans": [ + { + "bbox": [ + 105, + 201, + 505, + 215 + ], + "score": 1.0, + "content": "that there are several other recently developed variants of computing ES-gradients as well as apply-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 214, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 106, + 214, + 505, + 225 + ], + "score": 1.0, + "content": "ing them for optimization. We describe some of these variants in Section 3.3 and appendix A.3. A", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 224, + 457, + 236 + ], + "spans": [ + { + "bbox": [ + 106, + 224, + 457, + 236 + ], + "score": 1.0, + "content": "key feature of ES-MAML is that we can directly make use of new enhancements of ES.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9.5 + }, + { + "type": "title", + "bbox": [ + 108, + 248, + 281, + 260 + ], + "lines": [ + { + "bbox": [ + 105, + 247, + 282, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 247, + 282, + 261 + ], + "score": 1.0, + "content": "3.2 META-TRAINING MAML WITH ES", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 268, + 505, + 312 + ], + "lines": [ + { + "bbox": [ + 105, + 267, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 473, + 282 + ], + "score": 1.0, + "content": "To formulate MAML in the ES framework, we take a more abstract viewpoint. For each task", + "type": "text" + }, + { + "bbox": [ + 473, + 270, + 501, + 279 + ], + "score": 0.85, + "content": "T \\in { \\mathcal { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 267, + 505, + 282 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 279, + 504, + 292 + ], + "spans": [ + { + "bbox": [ + 106, + 279, + 119, + 291 + ], + "score": 1.0, + "content": "let", + "type": "text" + }, + { + "bbox": [ + 119, + 279, + 145, + 292 + ], + "score": 0.92, + "content": "f ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 279, + 345, + 291 + ], + "score": 1.0, + "content": "be the (expected) cumulative reward of the policy", + "type": "text" + }, + { + "bbox": [ + 345, + 280, + 351, + 290 + ], + "score": 0.75, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 352, + 279, + 391, + 291 + ], + "score": 1.0, + "content": ". We treat", + "type": "text" + }, + { + "bbox": [ + 391, + 279, + 404, + 291 + ], + "score": 0.89, + "content": "{ \\bf { \\bar { f } } } ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 279, + 504, + 291 + ], + "score": 1.0, + "content": "as a blackbox, and make", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 289, + 506, + 305 + ], + "spans": [ + { + "bbox": [ + 104, + 289, + 388, + 305 + ], + "score": 1.0, + "content": "no assumptions on its structure (so the task need not even be MDP, and", + "type": "text" + }, + { + "bbox": [ + 389, + 291, + 402, + 303 + ], + "score": 0.88, + "content": "f ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 289, + 506, + 305 + ], + "score": 1.0, + "content": "may be nonsmooth). The", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 300, + 205, + 314 + ], + "spans": [ + { + "bbox": [ + 105, + 300, + 205, + 314 + ], + "score": 1.0, + "content": "MAML problem is then", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 14.5 + }, + { + "type": "interline_equation", + "bbox": [ + 230, + 311, + 382, + 331 + ], + "lines": [ + { + "bbox": [ + 230, + 311, + 382, + 331 + ], + "spans": [ + { + "bbox": [ + 230, + 311, + 382, + 331 + ], + "score": 0.93, + "content": "\\operatorname* { m a x } _ { \\theta } J ( \\theta ) : = \\mathbb { E } _ { T \\sim \\mathcal { P } ( T ) } f ^ { T } ( U ( \\theta , T ) ) .", + "type": "interline_equation", + "image_path": "309d16109022cc74e9fa5486d1274defb43456fd15e10c36d19831b9fa716fd7.jpg" + } + ] + } + ], + "index": 17, + "virtual_lines": [ + { + "bbox": [ + 230, + 311, + 382, + 331 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 336, + 505, + 381 + ], + "lines": [ + { + "bbox": [ + 105, + 336, + 506, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 506, + 350 + ], + "score": 1.0, + "content": "As argued in (Liu et al., 2019; Rothfuss et al., 2019) (see also Section 2), a major challenge for", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 348, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 506, + 361 + ], + "score": 1.0, + "content": "policy gradient MAML is estimating the Hessian, which is both conceptually subtle and difficult to", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 359, + 506, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 506, + 371 + ], + "score": 1.0, + "content": "correctly implement using automatic differentiation. The algorithm we propose obviates the need to", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 370, + 345, + 382 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 345, + 382 + ], + "score": 1.0, + "content": "calculate any second derivatives, and thus avoids this issue.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 106, + 386, + 505, + 425 + ], + "lines": [ + { + "bbox": [ + 105, + 385, + 506, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 303, + 401 + ], + "score": 1.0, + "content": "Suppose that we can evaluate (or approximate)", + "type": "text" + }, + { + "bbox": [ + 304, + 386, + 329, + 399 + ], + "score": 0.93, + "content": "f ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 385, + 350, + 401 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 350, + 387, + 383, + 399 + ], + "score": 0.93, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 385, + 405, + 401 + ], + "score": 1.0, + "content": ", but", + "type": "text" + }, + { + "bbox": [ + 405, + 386, + 418, + 399 + ], + "score": 0.9, + "content": "f ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 385, + 438, + 401 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 439, + 387, + 470, + 399 + ], + "score": 0.91, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 385, + 506, + 401 + ], + "score": 1.0, + "content": "may be", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 398, + 504, + 412 + ], + "spans": [ + { + "bbox": [ + 106, + 400, + 464, + 412 + ], + "score": 1.0, + "content": "nonsmooth or their gradients may be intractable. We consider the Gaussian smoothing", + "type": "text" + }, + { + "bbox": [ + 465, + 398, + 477, + 411 + ], + "score": 0.89, + "content": "{ \\mathcal { \\widetilde { I } } } _ { \\sigma }", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 400, + 504, + 412 + ], + "score": 1.0, + "content": "of the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 411, + 464, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 240, + 426 + ], + "score": 1.0, + "content": "MAML reward (5), and optimize", + "type": "text" + }, + { + "bbox": [ + 241, + 411, + 253, + 424 + ], + "score": 0.9, + "content": "{ \\mathcal { \\widetilde { I } } } _ { \\sigma }", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 413, + 385, + 426 + ], + "score": 1.0, + "content": "using ES methods. The gradient", + "type": "text" + }, + { + "bbox": [ + 385, + 411, + 417, + 425 + ], + "score": 0.93, + "content": "\\nabla \\mathcal { I } _ { \\sigma } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 418, + 413, + 464, + 426 + ], + "score": 1.0, + "content": "is given by", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23 + }, + { + "type": "interline_equation", + "bbox": [ + 209, + 427, + 401, + 456 + ], + "lines": [ + { + "bbox": [ + 209, + 427, + 401, + 456 + ], + "spans": [ + { + "bbox": [ + 209, + 427, + 401, + 456 + ], + "score": 0.95, + "content": "\\nabla \\widetilde { J } _ { \\sigma } ( \\theta ) = \\mathbb { E } _ { T \\sim \\mathcal { P } ( T ) } \\left[ \\frac { 1 } { \\sigma } f ^ { T } ( U ( \\theta + \\sigma \\mathbf { g } , T ) ) \\mathbf { g } \\right]", + "type": "interline_equation", + "image_path": "0dc6d07d68edc7799a71943536845069dff4187c25968c2749c5ef5e57e74e49.jpg" + } + ] + } + ], + "index": 25.5, + "virtual_lines": [ + { + "bbox": [ + 209, + 427, + 401, + 441.5 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 209, + 441.5, + 401, + 456.0 + ], + "spans": [], + "index": 26 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 459, + 505, + 482 + ], + "lines": [ + { + "bbox": [ + 105, + 458, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 304, + 473 + ], + "score": 1.0, + "content": "and can be estimated by jointly sampling over", + "type": "text" + }, + { + "bbox": [ + 305, + 459, + 330, + 471 + ], + "score": 0.91, + "content": "( T , \\mathbf { g } )", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 458, + 396, + 473 + ], + "score": 1.0, + "content": "and evaluating", + "type": "text" + }, + { + "bbox": [ + 397, + 458, + 475, + 471 + ], + "score": 0.91, + "content": "f ^ { T } ( U ( \\theta + \\sigma { \\bf g } , T ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 458, + 506, + 473 + ], + "score": 1.0, + "content": ". This", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 470, + 456, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 456, + 483 + ], + "score": 1.0, + "content": "algorithm is specified in Algorithm 2 box, and we refer to it as (zero-order) ES-MAML.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 99, + 510, + 267, + 532 + ], + "lines": [ + { + "bbox": [ + 105, + 510, + 266, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 186, + 522 + ], + "score": 1.0, + "content": "Data: initial policy", + "type": "text" + }, + { + "bbox": [ + 186, + 511, + 196, + 521 + ], + "score": 0.88, + "content": "\\theta _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 197, + 510, + 258, + 522 + ], + "score": 1.0, + "content": ", meta step size", + "type": "text" + }, + { + "bbox": [ + 259, + 511, + 266, + 522 + ], + "score": 0.81, + "content": "\\beta", + "type": "inline_equation" + } + ], + "index": 29 + }, + { + "bbox": [ + 98, + 521, + 185, + 533 + ], + "spans": [ + { + "bbox": [ + 98, + 521, + 121, + 533 + ], + "score": 1.0, + "content": "1 for", + "type": "text" + }, + { + "bbox": [ + 122, + 522, + 170, + 533 + ], + "score": 0.79, + "content": "t = 0 , 1 , \\ldots", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 521, + 185, + 533 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 97, + 533, + 262, + 604 + ], + "lines": [ + { + "bbox": [ + 97, + 532, + 261, + 544 + ], + "spans": [ + { + "bbox": [ + 97, + 534, + 105, + 543 + ], + "score": 1.0, + "content": "2", + "type": "text" + }, + { + "bbox": [ + 121, + 532, + 154, + 544 + ], + "score": 1.0, + "content": "Sample", + "type": "text" + }, + { + "bbox": [ + 154, + 534, + 162, + 542 + ], + "score": 0.76, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 532, + 185, + 544 + ], + "score": 1.0, + "content": "tasks", + "type": "text" + }, + { + "bbox": [ + 185, + 533, + 230, + 543 + ], + "score": 0.92, + "content": "T _ { 1 } , \\ldots , T _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 532, + 261, + 544 + ], + "score": 1.0, + "content": "and iid", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 125, + 543, + 251, + 556 + ], + "spans": [ + { + "bbox": [ + 125, + 543, + 158, + 556 + ], + "score": 1.0, + "content": "vectors", + "type": "text" + }, + { + "bbox": [ + 158, + 544, + 248, + 555 + ], + "score": 0.88, + "content": "{ \\bf g } _ { 1 } , \\ldots , { \\bf g } _ { n } \\sim { \\mathcal N } ( 0 , { \\bf I } )", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 543, + 251, + 556 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 97, + 552, + 203, + 567 + ], + "spans": [ + { + "bbox": [ + 97, + 556, + 105, + 565 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 121, + 552, + 156, + 567 + ], + "score": 1.0, + "content": "foreach", + "type": "text" + }, + { + "bbox": [ + 157, + 555, + 187, + 565 + ], + "score": 0.75, + "content": "( T _ { i } , \\mathbf { g } _ { i } )", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 552, + 203, + 567 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 98, + 565, + 248, + 578 + ], + "spans": [ + { + "bbox": [ + 98, + 568, + 104, + 576 + ], + "score": 1.0, + "content": "4", + "type": "text" + }, + { + "bbox": [ + 124, + 565, + 248, + 578 + ], + "score": 0.75, + "content": "\\begin{array} { r l } { \\parallel } & { { } v _ { i } f ^ { T _ { i } } ( U ( \\theta _ { t } + \\sigma \\mathbf { g } _ { i } , T _ { i } ) ) } \\end{array}", + "type": "inline_equation" + } + ], + "index": 34 + }, + { + "bbox": [ + 97, + 576, + 141, + 589 + ], + "spans": [ + { + "bbox": [ + 97, + 579, + 105, + 588 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 120, + 576, + 141, + 589 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 98, + 588, + 234, + 604 + ], + "spans": [ + { + "bbox": [ + 98, + 593, + 104, + 601 + ], + "score": 1.0, + "content": "6", + "type": "text" + }, + { + "bbox": [ + 122, + 588, + 234, + 604 + ], + "score": 0.47, + "content": "\\begin{array} { r } { \\theta _ { t + 1 } \\theta _ { t } + \\frac { \\beta } { \\sigma n } \\sum _ { i = 1 } ^ { n } v _ { i } \\mathbf { g } _ { i } } \\end{array}", + "type": "inline_equation", + "image_path": "7b93aeaed592e83c56a44edab0151f6c5585feafcfb55ea65bc827a878f6eea9.jpg" + } + ], + "index": 36 + } + ], + "index": 33.5 + }, + { + "type": "text", + "bbox": [ + 99, + 604, + 124, + 613 + ], + "lines": [ + { + "bbox": [ + 97, + 602, + 125, + 614 + ], + "spans": [ + { + "bbox": [ + 97, + 602, + 125, + 614 + ], + "score": 1.0, + "content": "7 end", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 105, + 614, + 267, + 636 + ], + "lines": [ + { + "bbox": [ + 107, + 614, + 267, + 625 + ], + "spans": [ + { + "bbox": [ + 107, + 614, + 267, + 625 + ], + "score": 1.0, + "content": "Algorithm 2: Zero-Order ES-MAML", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 624, + 257, + 637 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 221, + 637 + ], + "score": 1.0, + "content": "(general adaptation operator", + "type": "text" + }, + { + "bbox": [ + 222, + 624, + 252, + 637 + ], + "score": 0.9, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 624, + 257, + 637 + ], + "score": 1.0, + "content": ")", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5 + }, + { + "type": "text", + "bbox": [ + 301, + 489, + 489, + 523 + ], + "lines": [ + { + "bbox": [ + 304, + 489, + 490, + 502 + ], + "spans": [ + { + "bbox": [ + 304, + 489, + 384, + 502 + ], + "score": 1.0, + "content": "Data: initial policy", + "type": "text" + }, + { + "bbox": [ + 384, + 490, + 394, + 501 + ], + "score": 0.87, + "content": "\\theta _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 395, + 489, + 479, + 502 + ], + "score": 1.0, + "content": ", adaptation step size", + "type": "text" + }, + { + "bbox": [ + 479, + 492, + 487, + 500 + ], + "score": 0.77, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 489, + 490, + 502 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 330, + 501, + 487, + 512 + ], + "spans": [ + { + "bbox": [ + 330, + 501, + 389, + 512 + ], + "score": 1.0, + "content": "meta step size", + "type": "text" + }, + { + "bbox": [ + 390, + 501, + 397, + 512 + ], + "score": 0.84, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 501, + 476, + 512 + ], + "score": 1.0, + "content": ", number of queries", + "type": "text" + }, + { + "bbox": [ + 476, + 501, + 487, + 510 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + } + ], + "index": 41 + }, + { + "bbox": [ + 304, + 511, + 383, + 524 + ], + "spans": [ + { + "bbox": [ + 304, + 511, + 319, + 524 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 320, + 512, + 372, + 523 + ], + "score": 0.77, + "content": "t = 0 , 1 , \\ldots { }", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 511, + 383, + 524 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41 + }, + { + "type": "interline_equation", + "bbox": [ + 319, + 609, + 433, + 625 + ], + "lines": [], + "index": 43, + "virtual_lines": [ + { + "bbox": [ + 319, + 609, + 433, + 625 + ], + "spans": [], + "index": 43 + } + ] + }, + { + "type": "text", + "bbox": [ + 303, + 635, + 504, + 657 + ], + "lines": [ + { + "bbox": [ + 304, + 634, + 504, + 646 + ], + "spans": [ + { + "bbox": [ + 304, + 634, + 504, + 646 + ], + "score": 1.0, + "content": "Algorithm 3: Zero-Order ES-MAML with ES-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 304, + 646, + 389, + 657 + ], + "spans": [ + { + "bbox": [ + 304, + 646, + 389, + 657 + ], + "score": 1.0, + "content": "Gradient Adaptation", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5 + }, + { + "type": "text", + "bbox": [ + 106, + 665, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 664, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 241, + 680 + ], + "score": 1.0, + "content": "The standard adaptation operator", + "type": "text" + }, + { + "bbox": [ + 241, + 666, + 272, + 678 + ], + "score": 0.93, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 664, + 417, + 680 + ], + "score": 1.0, + "content": "is the one-step task gradient. Since", + "type": "text" + }, + { + "bbox": [ + 417, + 665, + 431, + 677 + ], + "score": 0.88, + "content": "f ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 431, + 664, + 506, + 680 + ], + "score": 1.0, + "content": "is permitted to be", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 678, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 342, + 693 + ], + "score": 1.0, + "content": "nonsmooth in our setting, we use the adaptation operator", + "type": "text" + }, + { + "bbox": [ + 343, + 678, + 450, + 692 + ], + "score": 0.91, + "content": "U ( \\theta , T ) = \\theta + \\alpha \\nabla \\widetilde { f } _ { \\sigma } ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 678, + 505, + 693 + ], + "score": 1.0, + "content": "acting on its", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 690, + 497, + 707 + ], + "spans": [ + { + "bbox": [ + 105, + 691, + 266, + 707 + ], + "score": 1.0, + "content": "smoothing. Expanding the definition of", + "type": "text" + }, + { + "bbox": [ + 266, + 690, + 278, + 704 + ], + "score": 0.91, + "content": "{ \\mathcal { \\widetilde { I } } } _ { \\sigma }", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 691, + 497, + 707 + ], + "score": 1.0, + "content": ", the gradient of the smoothed MAML is then given by", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47 + }, + { + "type": "interline_equation", + "bbox": [ + 142, + 706, + 469, + 735 + ], + "lines": [ + { + "bbox": [ + 142, + 706, + 469, + 735 + ], + "spans": [ + { + "bbox": [ + 142, + 706, + 469, + 735 + ], + "score": 0.92, + "content": "\\nabla \\widetilde { J } _ { \\sigma } ( \\theta ) = \\frac { 1 } { \\sigma } \\mathbb { E } _ { T \\sim \\mathcal { P } ( \\mathcal { T } ) } \\left[ f ^ { T } \\left( \\theta + \\sigma \\mathbf { g } + \\frac { 1 } { \\sigma } \\mathbb { E } _ { \\mathbf { h } \\sim \\mathcal { N } ( 0 , \\mathbf { I } ) } [ f ^ { T } ( \\theta + \\sigma \\mathbf { g } + \\sigma \\mathbf { h } ) \\mathbf { h } ] \\right) \\mathbf { g } \\right] .", + "type": "interline_equation", + "image_path": "dd17152caad58b3c9993c23644884723b5921b9e9a17d5456f69b7f3e54c6f0d.jpg" + } + ] + } + ], + "index": 50, + "virtual_lines": [ + { + "bbox": [ + 142, + 706, + 469, + 715.6666666666666 + ], + "spans": [], + "index": 49 + }, + { + "bbox": [ + 142, + 715.6666666666666, + 469, + 725.3333333333333 + ], + "spans": [], + "index": 50 + }, + { + "bbox": [ + 142, + 725.3333333333333, + 469, + 734.9999999999999 + ], + "spans": [], + "index": 51 + } + ] + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 759 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "4", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 99, + 74, + 189, + 86 + ], + "lines": [ + { + "bbox": [ + 97, + 72, + 188, + 88 + ], + "spans": [ + { + "bbox": [ + 97, + 72, + 144, + 88 + ], + "score": 1.0, + "content": "1 ESGrad", + "type": "text" + }, + { + "bbox": [ + 145, + 74, + 188, + 86 + ], + "score": 0.9, + "content": "( f , \\theta , n , \\sigma )", + "type": "inline_equation" + } + ], + "index": 0 + } + ], + "index": 0, + "bbox_fs": [ + 97, + 72, + 188, + 88 + ] + }, + { + "type": "text", + "bbox": [ + 96, + 86, + 394, + 121 + ], + "lines": [ + { + "bbox": [ + 122, + 84, + 394, + 97 + ], + "spans": [ + { + "bbox": [ + 122, + 84, + 190, + 97 + ], + "score": 1.0, + "content": "inputs: function", + "type": "text" + }, + { + "bbox": [ + 190, + 86, + 197, + 96 + ], + "score": 0.82, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 84, + 228, + 97 + ], + "score": 1.0, + "content": ", policy", + "type": "text" + }, + { + "bbox": [ + 228, + 86, + 234, + 95 + ], + "score": 0.78, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 84, + 337, + 97 + ], + "score": 1.0, + "content": ", number of perturbations", + "type": "text" + }, + { + "bbox": [ + 337, + 88, + 344, + 95 + ], + "score": 0.69, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 344, + 84, + 387, + 97 + ], + "score": 1.0, + "content": ", precision", + "type": "text" + }, + { + "bbox": [ + 387, + 88, + 394, + 95 + ], + "score": 0.62, + "content": "\\sigma", + "type": "inline_equation" + } + ], + "index": 1 + }, + { + "bbox": [ + 98, + 94, + 293, + 110 + ], + "spans": [ + { + "bbox": [ + 98, + 99, + 104, + 106 + ], + "score": 1.0, + "content": "2", + "type": "text" + }, + { + "bbox": [ + 121, + 94, + 154, + 110 + ], + "score": 1.0, + "content": "Sample", + "type": "text" + }, + { + "bbox": [ + 154, + 97, + 162, + 106 + ], + "score": 0.71, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 94, + 181, + 110 + ], + "score": 1.0, + "content": "i.i.d", + "type": "text" + }, + { + "bbox": [ + 181, + 96, + 213, + 108 + ], + "score": 0.92, + "content": "N ( 0 , I )", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 94, + 245, + 110 + ], + "score": 1.0, + "content": "vectors", + "type": "text" + }, + { + "bbox": [ + 246, + 97, + 288, + 108 + ], + "score": 0.91, + "content": "g _ { 1 } , \\ldots , g _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 94, + 293, + 110 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 97, + 104, + 252, + 124 + ], + "spans": [ + { + "bbox": [ + 97, + 111, + 104, + 119 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 118, + 104, + 152, + 124 + ], + "score": 1.0, + "content": "return", + "type": "text" + }, + { + "bbox": [ + 153, + 108, + 245, + 122 + ], + "score": 0.88, + "content": "\\begin{array} { r } { { \\frac { 1 } { n \\sigma } } \\sum _ { i = 1 } ^ { n } f ( \\theta + \\sigma g _ { i } ) g _ { i } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 104, + 252, + 124 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2, + "bbox_fs": [ + 97, + 84, + 394, + 124 + ] + }, + { + "type": "text", + "bbox": [ + 225, + 120, + 386, + 132 + ], + "lines": [ + { + "bbox": [ + 224, + 119, + 387, + 132 + ], + "spans": [ + { + "bbox": [ + 224, + 119, + 387, + 132 + ], + "score": 1.0, + "content": "Algorithm 1: Monte Carlo ES Gradient", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4, + "bbox_fs": [ + 224, + 119, + 387, + 132 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 151, + 505, + 186 + ], + "lines": [ + { + "bbox": [ + 106, + 151, + 506, + 165 + ], + "spans": [ + { + "bbox": [ + 106, + 152, + 196, + 164 + ], + "score": 0.9, + "content": "\\boldsymbol { \\sigma } \\mathbf { g } ) - f ( \\boldsymbol { \\theta } - \\boldsymbol { \\sigma } \\mathbf { g } ) ) \\mathbf { g } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 151, + 506, + 165 + ], + "score": 1.0, + "content": ". Notice that the variance of the Forward-FD and antithetic estimators is", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 163, + 504, + 175 + ], + "spans": [ + { + "bbox": [ + 106, + 163, + 250, + 175 + ], + "score": 1.0, + "content": "translation-invariant with respect to", + "type": "text" + }, + { + "bbox": [ + 250, + 164, + 257, + 175 + ], + "score": 0.83, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 163, + 504, + 175 + ], + "score": 1.0, + "content": ". In practice, the Forward-FD or antithetic estimator is usually", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 174, + 333, + 187 + ], + "spans": [ + { + "bbox": [ + 106, + 174, + 333, + 187 + ], + "score": 1.0, + "content": "preferred over the basic version expressed in equation 4.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6, + "bbox_fs": [ + 106, + 151, + 506, + 187 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 191, + 505, + 236 + ], + "lines": [ + { + "bbox": [ + 105, + 191, + 505, + 204 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 505, + 204 + ], + "score": 1.0, + "content": "In the next sections we will refer to Algorithm 1 for computing the gradient though we emphasize", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 201, + 505, + 215 + ], + "spans": [ + { + "bbox": [ + 105, + 201, + 505, + 215 + ], + "score": 1.0, + "content": "that there are several other recently developed variants of computing ES-gradients as well as apply-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 214, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 106, + 214, + 505, + 225 + ], + "score": 1.0, + "content": "ing them for optimization. We describe some of these variants in Section 3.3 and appendix A.3. A", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 224, + 457, + 236 + ], + "spans": [ + { + "bbox": [ + 106, + 224, + 457, + 236 + ], + "score": 1.0, + "content": "key feature of ES-MAML is that we can directly make use of new enhancements of ES.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 191, + 505, + 236 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 248, + 281, + 260 + ], + "lines": [ + { + "bbox": [ + 105, + 247, + 282, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 247, + 282, + 261 + ], + "score": 1.0, + "content": "3.2 META-TRAINING MAML WITH ES", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 268, + 505, + 312 + ], + "lines": [ + { + "bbox": [ + 105, + 267, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 473, + 282 + ], + "score": 1.0, + "content": "To formulate MAML in the ES framework, we take a more abstract viewpoint. For each task", + "type": "text" + }, + { + "bbox": [ + 473, + 270, + 501, + 279 + ], + "score": 0.85, + "content": "T \\in { \\mathcal { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 267, + 505, + 282 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 279, + 504, + 292 + ], + "spans": [ + { + "bbox": [ + 106, + 279, + 119, + 291 + ], + "score": 1.0, + "content": "let", + "type": "text" + }, + { + "bbox": [ + 119, + 279, + 145, + 292 + ], + "score": 0.92, + "content": "f ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 279, + 345, + 291 + ], + "score": 1.0, + "content": "be the (expected) cumulative reward of the policy", + "type": "text" + }, + { + "bbox": [ + 345, + 280, + 351, + 290 + ], + "score": 0.75, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 352, + 279, + 391, + 291 + ], + "score": 1.0, + "content": ". We treat", + "type": "text" + }, + { + "bbox": [ + 391, + 279, + 404, + 291 + ], + "score": 0.89, + "content": "{ \\bf { \\bar { f } } } ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 279, + 504, + 291 + ], + "score": 1.0, + "content": "as a blackbox, and make", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 289, + 506, + 305 + ], + "spans": [ + { + "bbox": [ + 104, + 289, + 388, + 305 + ], + "score": 1.0, + "content": "no assumptions on its structure (so the task need not even be MDP, and", + "type": "text" + }, + { + "bbox": [ + 389, + 291, + 402, + 303 + ], + "score": 0.88, + "content": "f ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 289, + 506, + 305 + ], + "score": 1.0, + "content": "may be nonsmooth). The", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 300, + 205, + 314 + ], + "spans": [ + { + "bbox": [ + 105, + 300, + 205, + 314 + ], + "score": 1.0, + "content": "MAML problem is then", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 14.5, + "bbox_fs": [ + 104, + 267, + 506, + 314 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 230, + 311, + 382, + 331 + ], + "lines": [ + { + "bbox": [ + 230, + 311, + 382, + 331 + ], + "spans": [ + { + "bbox": [ + 230, + 311, + 382, + 331 + ], + "score": 0.93, + "content": "\\operatorname* { m a x } _ { \\theta } J ( \\theta ) : = \\mathbb { E } _ { T \\sim \\mathcal { P } ( T ) } f ^ { T } ( U ( \\theta , T ) ) .", + "type": "interline_equation", + "image_path": "309d16109022cc74e9fa5486d1274defb43456fd15e10c36d19831b9fa716fd7.jpg" + } + ] + } + ], + "index": 17, + "virtual_lines": [ + { + "bbox": [ + 230, + 311, + 382, + 331 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 336, + 505, + 381 + ], + "lines": [ + { + "bbox": [ + 105, + 336, + 506, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 506, + 350 + ], + "score": 1.0, + "content": "As argued in (Liu et al., 2019; Rothfuss et al., 2019) (see also Section 2), a major challenge for", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 348, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 506, + 361 + ], + "score": 1.0, + "content": "policy gradient MAML is estimating the Hessian, which is both conceptually subtle and difficult to", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 359, + 506, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 506, + 371 + ], + "score": 1.0, + "content": "correctly implement using automatic differentiation. The algorithm we propose obviates the need to", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 370, + 345, + 382 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 345, + 382 + ], + "score": 1.0, + "content": "calculate any second derivatives, and thus avoids this issue.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 336, + 506, + 382 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 386, + 505, + 425 + ], + "lines": [ + { + "bbox": [ + 105, + 385, + 506, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 303, + 401 + ], + "score": 1.0, + "content": "Suppose that we can evaluate (or approximate)", + "type": "text" + }, + { + "bbox": [ + 304, + 386, + 329, + 399 + ], + "score": 0.93, + "content": "f ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 385, + 350, + 401 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 350, + 387, + 383, + 399 + ], + "score": 0.93, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 385, + 405, + 401 + ], + "score": 1.0, + "content": ", but", + "type": "text" + }, + { + "bbox": [ + 405, + 386, + 418, + 399 + ], + "score": 0.9, + "content": "f ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 385, + 438, + 401 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 439, + 387, + 470, + 399 + ], + "score": 0.91, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 385, + 506, + 401 + ], + "score": 1.0, + "content": "may be", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 398, + 504, + 412 + ], + "spans": [ + { + "bbox": [ + 106, + 400, + 464, + 412 + ], + "score": 1.0, + "content": "nonsmooth or their gradients may be intractable. We consider the Gaussian smoothing", + "type": "text" + }, + { + "bbox": [ + 465, + 398, + 477, + 411 + ], + "score": 0.89, + "content": "{ \\mathcal { \\widetilde { I } } } _ { \\sigma }", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 400, + 504, + 412 + ], + "score": 1.0, + "content": "of the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 411, + 464, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 240, + 426 + ], + "score": 1.0, + "content": "MAML reward (5), and optimize", + "type": "text" + }, + { + "bbox": [ + 241, + 411, + 253, + 424 + ], + "score": 0.9, + "content": "{ \\mathcal { \\widetilde { I } } } _ { \\sigma }", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 413, + 385, + 426 + ], + "score": 1.0, + "content": "using ES methods. The gradient", + "type": "text" + }, + { + "bbox": [ + 385, + 411, + 417, + 425 + ], + "score": 0.93, + "content": "\\nabla \\mathcal { I } _ { \\sigma } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 418, + 413, + 464, + 426 + ], + "score": 1.0, + "content": "is given by", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 385, + 506, + 426 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 209, + 427, + 401, + 456 + ], + "lines": [ + { + "bbox": [ + 209, + 427, + 401, + 456 + ], + "spans": [ + { + "bbox": [ + 209, + 427, + 401, + 456 + ], + "score": 0.95, + "content": "\\nabla \\widetilde { J } _ { \\sigma } ( \\theta ) = \\mathbb { E } _ { T \\sim \\mathcal { P } ( T ) } \\left[ \\frac { 1 } { \\sigma } f ^ { T } ( U ( \\theta + \\sigma \\mathbf { g } , T ) ) \\mathbf { g } \\right]", + "type": "interline_equation", + "image_path": "0dc6d07d68edc7799a71943536845069dff4187c25968c2749c5ef5e57e74e49.jpg" + } + ] + } + ], + "index": 25.5, + "virtual_lines": [ + { + "bbox": [ + 209, + 427, + 401, + 441.5 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 209, + 441.5, + 401, + 456.0 + ], + "spans": [], + "index": 26 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 459, + 505, + 482 + ], + "lines": [ + { + "bbox": [ + 105, + 458, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 304, + 473 + ], + "score": 1.0, + "content": "and can be estimated by jointly sampling over", + "type": "text" + }, + { + "bbox": [ + 305, + 459, + 330, + 471 + ], + "score": 0.91, + "content": "( T , \\mathbf { g } )", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 458, + 396, + 473 + ], + "score": 1.0, + "content": "and evaluating", + "type": "text" + }, + { + "bbox": [ + 397, + 458, + 475, + 471 + ], + "score": 0.91, + "content": "f ^ { T } ( U ( \\theta + \\sigma { \\bf g } , T ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 458, + 506, + 473 + ], + "score": 1.0, + "content": ". This", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 470, + 456, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 456, + 483 + ], + "score": 1.0, + "content": "algorithm is specified in Algorithm 2 box, and we refer to it as (zero-order) ES-MAML.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 458, + 506, + 483 + ] + }, + { + "type": "text", + "bbox": [ + 99, + 510, + 267, + 532 + ], + "lines": [ + { + "bbox": [ + 105, + 510, + 266, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 186, + 522 + ], + "score": 1.0, + "content": "Data: initial policy", + "type": "text" + }, + { + "bbox": [ + 186, + 511, + 196, + 521 + ], + "score": 0.88, + "content": "\\theta _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 197, + 510, + 258, + 522 + ], + "score": 1.0, + "content": ", meta step size", + "type": "text" + }, + { + "bbox": [ + 259, + 511, + 266, + 522 + ], + "score": 0.81, + "content": "\\beta", + "type": "inline_equation" + } + ], + "index": 29 + }, + { + "bbox": [ + 98, + 521, + 185, + 533 + ], + "spans": [ + { + "bbox": [ + 98, + 521, + 121, + 533 + ], + "score": 1.0, + "content": "1 for", + "type": "text" + }, + { + "bbox": [ + 122, + 522, + 170, + 533 + ], + "score": 0.79, + "content": "t = 0 , 1 , \\ldots", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 521, + 185, + 533 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5, + "bbox_fs": [ + 98, + 510, + 266, + 533 + ] + }, + { + "type": "index", + "bbox": [ + 97, + 533, + 262, + 604 + ], + "lines": [ + { + "bbox": [ + 97, + 532, + 261, + 544 + ], + "spans": [ + { + "bbox": [ + 97, + 534, + 105, + 543 + ], + "score": 1.0, + "content": "2", + "type": "text" + }, + { + "bbox": [ + 121, + 532, + 154, + 544 + ], + "score": 1.0, + "content": "Sample", + "type": "text" + }, + { + "bbox": [ + 154, + 534, + 162, + 542 + ], + "score": 0.76, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 532, + 185, + 544 + ], + "score": 1.0, + "content": "tasks", + "type": "text" + }, + { + "bbox": [ + 185, + 533, + 230, + 543 + ], + "score": 0.92, + "content": "T _ { 1 } , \\ldots , T _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 532, + 261, + 544 + ], + "score": 1.0, + "content": "and iid", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 125, + 543, + 251, + 556 + ], + "spans": [ + { + "bbox": [ + 125, + 543, + 158, + 556 + ], + "score": 1.0, + "content": "vectors", + "type": "text" + }, + { + "bbox": [ + 158, + 544, + 248, + 555 + ], + "score": 0.88, + "content": "{ \\bf g } _ { 1 } , \\ldots , { \\bf g } _ { n } \\sim { \\mathcal N } ( 0 , { \\bf I } )", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 543, + 251, + 556 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 32, + "is_list_start_line": true + }, + { + "bbox": [ + 97, + 552, + 203, + 567 + ], + "spans": [ + { + "bbox": [ + 97, + 556, + 105, + 565 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 121, + 552, + 156, + 567 + ], + "score": 1.0, + "content": "foreach", + "type": "text" + }, + { + "bbox": [ + 157, + 555, + 187, + 565 + ], + "score": 0.75, + "content": "( T _ { i } , \\mathbf { g } _ { i } )", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 552, + 203, + 567 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 98, + 565, + 248, + 578 + ], + "spans": [ + { + "bbox": [ + 98, + 568, + 104, + 576 + ], + "score": 1.0, + "content": "4", + "type": "text" + }, + { + "bbox": [ + 124, + 565, + 248, + 578 + ], + "score": 0.75, + "content": "\\begin{array} { r l } { \\parallel } & { { } v _ { i } f ^ { T _ { i } } ( U ( \\theta _ { t } + \\sigma \\mathbf { g } _ { i } , T _ { i } ) ) } \\end{array}", + "type": "inline_equation" + } + ], + "index": 34, + "is_list_start_line": true + }, + { + "bbox": [ + 97, + 576, + 141, + 589 + ], + "spans": [ + { + "bbox": [ + 97, + 579, + 105, + 588 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 120, + 576, + 141, + 589 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 98, + 588, + 234, + 604 + ], + "spans": [ + { + "bbox": [ + 98, + 593, + 104, + 601 + ], + "score": 1.0, + "content": "6", + "type": "text" + }, + { + "bbox": [ + 122, + 588, + 234, + 604 + ], + "score": 0.47, + "content": "\\begin{array} { r } { \\theta _ { t + 1 } \\theta _ { t } + \\frac { \\beta } { \\sigma n } \\sum _ { i = 1 } ^ { n } v _ { i } \\mathbf { g } _ { i } } \\end{array}", + "type": "inline_equation", + "image_path": "7b93aeaed592e83c56a44edab0151f6c5585feafcfb55ea65bc827a878f6eea9.jpg" + } + ], + "index": 36, + "is_list_start_line": true + } + ], + "index": 33.5, + "bbox_fs": [ + 97, + 532, + 261, + 604 + ] + }, + { + "type": "text", + "bbox": [ + 99, + 604, + 124, + 613 + ], + "lines": [ + { + "bbox": [ + 97, + 602, + 125, + 614 + ], + "spans": [ + { + "bbox": [ + 97, + 602, + 125, + 614 + ], + "score": 1.0, + "content": "7 end", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37, + "bbox_fs": [ + 97, + 602, + 125, + 614 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 614, + 267, + 636 + ], + "lines": [ + { + "bbox": [ + 107, + 614, + 267, + 625 + ], + "spans": [ + { + "bbox": [ + 107, + 614, + 267, + 625 + ], + "score": 1.0, + "content": "Algorithm 2: Zero-Order ES-MAML", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 624, + 257, + 637 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 221, + 637 + ], + "score": 1.0, + "content": "(general adaptation operator", + "type": "text" + }, + { + "bbox": [ + 222, + 624, + 252, + 637 + ], + "score": 0.9, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 624, + 257, + 637 + ], + "score": 1.0, + "content": ")", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5, + "bbox_fs": [ + 106, + 614, + 267, + 637 + ] + }, + { + "type": "text", + "bbox": [ + 301, + 489, + 489, + 523 + ], + "lines": [ + { + "bbox": [ + 304, + 489, + 490, + 502 + ], + "spans": [ + { + "bbox": [ + 304, + 489, + 384, + 502 + ], + "score": 1.0, + "content": "Data: initial policy", + "type": "text" + }, + { + "bbox": [ + 384, + 490, + 394, + 501 + ], + "score": 0.87, + "content": "\\theta _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 395, + 489, + 479, + 502 + ], + "score": 1.0, + "content": ", adaptation step size", + "type": "text" + }, + { + "bbox": [ + 479, + 492, + 487, + 500 + ], + "score": 0.77, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 489, + 490, + 502 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 330, + 501, + 487, + 512 + ], + "spans": [ + { + "bbox": [ + 330, + 501, + 389, + 512 + ], + "score": 1.0, + "content": "meta step size", + "type": "text" + }, + { + "bbox": [ + 390, + 501, + 397, + 512 + ], + "score": 0.84, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 501, + 476, + 512 + ], + "score": 1.0, + "content": ", number of queries", + "type": "text" + }, + { + "bbox": [ + 476, + 501, + 487, + 510 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + } + ], + "index": 41 + }, + { + "bbox": [ + 304, + 511, + 383, + 524 + ], + "spans": [ + { + "bbox": [ + 304, + 511, + 319, + 524 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 320, + 512, + 372, + 523 + ], + "score": 0.77, + "content": "t = 0 , 1 , \\ldots { }", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 511, + 383, + 524 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41, + "bbox_fs": [ + 304, + 489, + 490, + 524 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 319, + 609, + 433, + 625 + ], + "lines": [], + "index": 43, + "virtual_lines": [ + { + "bbox": [ + 319, + 609, + 433, + 625 + ], + "spans": [], + "index": 43 + } + ] + }, + { + "type": "text", + "bbox": [ + 303, + 635, + 504, + 657 + ], + "lines": [ + { + "bbox": [ + 304, + 634, + 504, + 646 + ], + "spans": [ + { + "bbox": [ + 304, + 634, + 504, + 646 + ], + "score": 1.0, + "content": "Algorithm 3: Zero-Order ES-MAML with ES-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 304, + 646, + 389, + 657 + ], + "spans": [ + { + "bbox": [ + 304, + 646, + 389, + 657 + ], + "score": 1.0, + "content": "Gradient Adaptation", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5, + "bbox_fs": [ + 304, + 634, + 504, + 657 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 665, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 664, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 241, + 680 + ], + "score": 1.0, + "content": "The standard adaptation operator", + "type": "text" + }, + { + "bbox": [ + 241, + 666, + 272, + 678 + ], + "score": 0.93, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 664, + 417, + 680 + ], + "score": 1.0, + "content": "is the one-step task gradient. Since", + "type": "text" + }, + { + "bbox": [ + 417, + 665, + 431, + 677 + ], + "score": 0.88, + "content": "f ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 431, + 664, + 506, + 680 + ], + "score": 1.0, + "content": "is permitted to be", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 678, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 342, + 693 + ], + "score": 1.0, + "content": "nonsmooth in our setting, we use the adaptation operator", + "type": "text" + }, + { + "bbox": [ + 343, + 678, + 450, + 692 + ], + "score": 0.91, + "content": "U ( \\theta , T ) = \\theta + \\alpha \\nabla \\widetilde { f } _ { \\sigma } ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 678, + 505, + 693 + ], + "score": 1.0, + "content": "acting on its", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 690, + 497, + 707 + ], + "spans": [ + { + "bbox": [ + 105, + 691, + 266, + 707 + ], + "score": 1.0, + "content": "smoothing. Expanding the definition of", + "type": "text" + }, + { + "bbox": [ + 266, + 690, + 278, + 704 + ], + "score": 0.91, + "content": "{ \\mathcal { \\widetilde { I } } } _ { \\sigma }", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 691, + 497, + 707 + ], + "score": 1.0, + "content": ", the gradient of the smoothed MAML is then given by", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47, + "bbox_fs": [ + 105, + 664, + 506, + 707 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 142, + 706, + 469, + 735 + ], + "lines": [ + { + "bbox": [ + 142, + 706, + 469, + 735 + ], + "spans": [ + { + "bbox": [ + 142, + 706, + 469, + 735 + ], + "score": 0.92, + "content": "\\nabla \\widetilde { J } _ { \\sigma } ( \\theta ) = \\frac { 1 } { \\sigma } \\mathbb { E } _ { T \\sim \\mathcal { P } ( \\mathcal { T } ) } \\left[ f ^ { T } \\left( \\theta + \\sigma \\mathbf { g } + \\frac { 1 } { \\sigma } \\mathbb { E } _ { \\mathbf { h } \\sim \\mathcal { N } ( 0 , \\mathbf { I } ) } [ f ^ { T } ( \\theta + \\sigma \\mathbf { g } + \\sigma \\mathbf { h } ) \\mathbf { h } ] \\right) \\mathbf { g } \\right] .", + "type": "interline_equation", + "image_path": "dd17152caad58b3c9993c23644884723b5921b9e9a17d5456f69b7f3e54c6f0d.jpg" + } + ] + } + ], + "index": 50, + "virtual_lines": [ + { + "bbox": [ + 142, + 706, + 469, + 715.6666666666666 + ], + "spans": [], + "index": 49 + }, + { + "bbox": [ + 142, + 715.6666666666666, + 469, + 725.3333333333333 + ], + "spans": [], + "index": 50 + }, + { + "bbox": [ + 142, + 725.3333333333333, + 469, + 734.9999999999999 + ], + "spans": [], + "index": 51 + } + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 464, + 97 + ], + "score": 1.0, + "content": "This leads to the algorithm that we specify in Algorithm 3, where the adaptation operator", + "type": "text" + }, + { + "bbox": [ + 464, + 83, + 494, + 95 + ], + "score": 0.92, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 80, + 506, + 97 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 327, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 327, + 107 + ], + "score": 1.0, + "content": "itself estimated using the ES gradient in the inner loop.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 105, + 110, + 504, + 136 + ], + "lines": [ + { + "bbox": [ + 105, + 108, + 506, + 124 + ], + "spans": [ + { + "bbox": [ + 105, + 108, + 506, + 124 + ], + "score": 1.0, + "content": "We can also derive an algorithm analogous to PG-MAML by applying a first-order method to the", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 120, + 502, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 120, + 170, + 138 + ], + "score": 1.0, + "content": "MAML reward", + "type": "text" + }, + { + "bbox": [ + 170, + 121, + 285, + 137 + ], + "score": 0.92, + "content": "\\mathbb { E } _ { T \\sim \\mathcal { P } ( \\mathcal { T } ) } \\overline { { \\hat { f } ^ { T } } } ( \\theta + \\alpha \\nabla \\tilde { f } ^ { T } ( \\theta ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 286, + 120, + 502, + 138 + ], + "score": 1.0, + "content": "directly, without smoothing. The gradient is given by", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5 + }, + { + "type": "interline_equation", + "bbox": [ + 186, + 146, + 424, + 164 + ], + "lines": [ + { + "bbox": [ + 186, + 146, + 424, + 164 + ], + "spans": [ + { + "bbox": [ + 186, + 146, + 424, + 164 + ], + "score": 0.89, + "content": "\\nabla J ( \\theta ) = \\mathbb { E } _ { T \\sim \\mathcal { P } ( \\mathcal { T } ) } \\nabla \\widetilde { f } ^ { T } ( \\theta + \\alpha \\nabla \\widetilde { f } ^ { T } ( \\theta ) ) ( \\mathbf { I } + \\alpha \\nabla ^ { 2 } \\widetilde { f } ^ { T } ( \\theta ) ) ,", + "type": "interline_equation", + "image_path": "6402d220c9be2f4c97dc7a0710f6709fb22c773f659786cd30b71009f4322997.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 186, + 146, + 424, + 164 + ], + "spans": [], + "index": 4 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 172, + 505, + 272 + ], + "lines": [ + { + "bbox": [ + 106, + 174, + 504, + 185 + ], + "spans": [ + { + "bbox": [ + 106, + 174, + 504, + 185 + ], + "score": 1.0, + "content": "which corresponds to equation (3) in (Liu et al., 2019) when expressed in terms of policy gradients.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 184, + 504, + 196 + ], + "spans": [ + { + "bbox": [ + 106, + 184, + 504, + 196 + ], + "score": 1.0, + "content": "Every term in this expression has a simple Monte Carlo estimator (see Algorithm 4 in the appendix", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 195, + 506, + 208 + ], + "spans": [ + { + "bbox": [ + 106, + 195, + 506, + 208 + ], + "score": 1.0, + "content": "for the MC Hessian estimator). We discuss this algorithm in greater detail in Appendix A.1. This", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 206, + 505, + 219 + ], + "spans": [ + { + "bbox": [ + 105, + 206, + 505, + 219 + ], + "score": 1.0, + "content": "formulation can be viewed as the “MAML of the smoothing”, compared to the “smoothing of the", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 216, + 506, + 230 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 506, + 230 + ], + "score": 1.0, + "content": "MAML” which is the basis for Algorithm 3. It is the additional smoothing present in equation 6", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 227, + 505, + 240 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 240, + 240 + ], + "score": 1.0, + "content": "which eliminates the gradient of", + "type": "text" + }, + { + "bbox": [ + 240, + 228, + 271, + 240 + ], + "score": 0.92, + "content": "U { \\bar { ( } } \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 227, + 383, + 240 + ], + "score": 1.0, + "content": "(and hence, the Hessian of", + "type": "text" + }, + { + "bbox": [ + 383, + 227, + 396, + 239 + ], + "score": 0.88, + "content": "f ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 227, + 505, + 240 + ], + "score": 1.0, + "content": "). Just as with the Hessian", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 238, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 106, + 238, + 505, + 252 + ], + "score": 1.0, + "content": "estimation in the original PG-MAML, we find empirically that the MC estimator of the Hessian", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 249, + 506, + 263 + ], + "spans": [ + { + "bbox": [ + 106, + 249, + 506, + 263 + ], + "score": 1.0, + "content": "(Algorithm 4) has high variance, making it often harmful in training. We present some comparisons", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 261, + 486, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 486, + 273 + ], + "score": 1.0, + "content": "between Algorithm 3 and Algorithm 5, with and without the Hessian term, in Appendix A.1.2.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 108, + 279, + 503, + 313 + ], + "lines": [ + { + "bbox": [ + 106, + 277, + 505, + 292 + ], + "spans": [ + { + "bbox": [ + 106, + 279, + 169, + 292 + ], + "score": 1.0, + "content": "Note that when", + "type": "text" + }, + { + "bbox": [ + 170, + 280, + 201, + 291 + ], + "score": 0.92, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 279, + 455, + 292 + ], + "score": 1.0, + "content": "is estimated, such as in Algorithm 3, the resulting estimator for", + "type": "text" + }, + { + "bbox": [ + 455, + 277, + 475, + 291 + ], + "score": 0.92, + "content": "\\nabla \\mathcal { \\tilde { I } } _ { \\sigma }", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 279, + 505, + 292 + ], + "score": 1.0, + "content": "will in", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 290, + 505, + 303 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 505, + 303 + ], + "score": 1.0, + "content": "general be biased. This is similar to the estimator bias which occurs in PG-MAML because we do", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 302, + 504, + 314 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 504, + 314 + ], + "score": 1.0, + "content": "not have access to the true adapted trajectory distribution. We discuss this further in Appendix A.2.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15 + }, + { + "type": "title", + "bbox": [ + 107, + 332, + 348, + 343 + ], + "lines": [ + { + "bbox": [ + 105, + 331, + 349, + 344 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 349, + 344 + ], + "score": 1.0, + "content": "3.3 IMPROVING THE ADAPTATION OPERATOR WITH ES", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 355, + 505, + 388 + ], + "lines": [ + { + "bbox": [ + 106, + 356, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 106, + 356, + 505, + 368 + ], + "score": 1.0, + "content": "Algorithm 2 allows for great flexibility in choosing new adaptation operators. The simplest extension", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 366, + 505, + 379 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 505, + 379 + ], + "score": 1.0, + "content": "is to modify the ES gradient step: we can draw on general techniques for improving the ES gradient", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 378, + 502, + 390 + ], + "spans": [ + { + "bbox": [ + 106, + 378, + 502, + 390 + ], + "score": 1.0, + "content": "estimator, some of which are described in Appendix A.3. Some other methods are explored below.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19 + }, + { + "type": "title", + "bbox": [ + 108, + 407, + 249, + 418 + ], + "lines": [ + { + "bbox": [ + 105, + 406, + 251, + 419 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 251, + 419 + ], + "score": 1.0, + "content": "3.3.1 IMPROVED EXPLORATION", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 428, + 505, + 516 + ], + "lines": [ + { + "bbox": [ + 105, + 428, + 505, + 441 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 384, + 441 + ], + "score": 1.0, + "content": "Instead of using i.i.d Gaussian vectors to estimate the ES gradient in", + "type": "text" + }, + { + "bbox": [ + 384, + 428, + 415, + 441 + ], + "score": 0.93, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 429, + 505, + 441 + ], + "score": 1.0, + "content": ", we consider samples", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 439, + 505, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 505, + 452 + ], + "score": 1.0, + "content": "constructed according to Determinantal Point Processes (DPP). DPP sampling (Kulesza & Taskar,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 450, + 505, + 463 + ], + "spans": [ + { + "bbox": [ + 106, + 450, + 505, + 463 + ], + "score": 1.0, + "content": "2012; Wachinger & Golland, 2015) is a method of selecting a subset of samples so as to maximize", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 461, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 414, + 474 + ], + "score": 1.0, + "content": "the ‘diversity’ of the subset. It has been applied to ES to select perturbations", + "type": "text" + }, + { + "bbox": [ + 414, + 463, + 425, + 473 + ], + "score": 0.85, + "content": "\\mathbf { g } _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 461, + 505, + 474 + ], + "score": 1.0, + "content": "so that the gradient", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 473, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 505, + 484 + ], + "score": 1.0, + "content": "estimator has lower variance (Choromanski et al., 2019a). The sampling matrix determining DPP", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 482, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 506, + 496 + ], + "score": 1.0, + "content": "sampling can also be data-dependent and use information from the meta-training stage to construct", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 494, + 505, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 505, + 506 + ], + "score": 1.0, + "content": "a learned kernel with better properties for the adaptation phase. In the experimental section we show", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 505, + 339, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 339, + 518 + ], + "score": 1.0, + "content": "that DPP-ES can help in improving adaptation in MAML.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 25.5 + }, + { + "type": "title", + "bbox": [ + 108, + 534, + 326, + 546 + ], + "lines": [ + { + "bbox": [ + 106, + 534, + 327, + 547 + ], + "spans": [ + { + "bbox": [ + 106, + 534, + 327, + 547 + ], + "score": 1.0, + "content": "3.3.2 HILL CLIMBING AND POPULATION SEARCH", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 107, + 556, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 555, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 220, + 569 + ], + "score": 1.0, + "content": "Nondifferentiable operators", + "type": "text" + }, + { + "bbox": [ + 221, + 556, + 252, + 568 + ], + "score": 0.93, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 555, + 505, + 569 + ], + "score": 1.0, + "content": "can be also used in Algorithm 2. One particularly interesting", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 567, + 505, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 301, + 580 + ], + "score": 1.0, + "content": "example is the local search operator given by", + "type": "text" + }, + { + "bbox": [ + 302, + 567, + 501, + 579 + ], + "score": 0.86, + "content": "U ( \\theta , T ) ~ \\stackrel { \\scriptscriptstyle = } { = } ~ \\mathrm { a r g m a x } \\{ f ^ { T } ( \\theta ^ { \\prime } ) ~ : ~ \\| \\theta ^ { \\prime } ~ \\stackrel { \\scriptscriptstyle < } { - } ~ \\theta \\| ~ \\le ~ R \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 567, + 505, + 580 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 577, + 506, + 591 + ], + "spans": [ + { + "bbox": [ + 106, + 577, + 133, + 591 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 578, + 162, + 588 + ], + "score": 0.9, + "content": "R > 0", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 577, + 281, + 591 + ], + "score": 1.0, + "content": "is the search radius. That is,", + "type": "text" + }, + { + "bbox": [ + 281, + 578, + 314, + 590 + ], + "score": 0.93, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 577, + 441, + 591 + ], + "score": 1.0, + "content": "selects the best policy for task", + "type": "text" + }, + { + "bbox": [ + 441, + 579, + 449, + 588 + ], + "score": 0.8, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 577, + 506, + 591 + ], + "score": 1.0, + "content": "which is in a", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 588, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 182, + 603 + ], + "score": 1.0, + "content": "‘neighborhood’ of", + "type": "text" + }, + { + "bbox": [ + 182, + 590, + 189, + 599 + ], + "score": 0.75, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 588, + 447, + 603 + ], + "score": 1.0, + "content": ". For simplicity, we took the search neighborhood to be the ball", + "type": "text" + }, + { + "bbox": [ + 447, + 589, + 481, + 601 + ], + "score": 0.93, + "content": "B ( \\theta , R )", + "type": "inline_equation" + }, + { + "bbox": [ + 481, + 588, + 506, + 603 + ], + "score": 1.0, + "content": "here,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 599, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 314, + 613 + ], + "score": 1.0, + "content": "but we may also use more general neighborhoods of", + "type": "text" + }, + { + "bbox": [ + 315, + 601, + 320, + 610 + ], + "score": 0.73, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 599, + 506, + 613 + ], + "score": 1.0, + "content": ". In general, exactly solving for the maximizer", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 104, + 609, + 506, + 625 + ], + "spans": [ + { + "bbox": [ + 104, + 609, + 117, + 625 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 117, + 610, + 130, + 623 + ], + "score": 0.91, + "content": "f ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 131, + 609, + 151, + 625 + ], + "score": 1.0, + "content": "over", + "type": "text" + }, + { + "bbox": [ + 151, + 611, + 185, + 623 + ], + "score": 0.93, + "content": "B ( \\theta , R )", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 609, + 506, + 625 + ], + "score": 1.0, + "content": "is intractable, but local search can often be well approximated by a hill climbing", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 622, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 106, + 622, + 505, + 635 + ], + "score": 1.0, + "content": "algorithm. Hill climbing creates a population of candidate policies by perturbing the best observed", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 632, + 506, + 645 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 227, + 645 + ], + "score": 1.0, + "content": "policy (which is initialized to", + "type": "text" + }, + { + "bbox": [ + 227, + 634, + 234, + 643 + ], + "score": 0.66, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 633, + 325, + 645 + ], + "score": 1.0, + "content": "), evaluates the reward", + "type": "text" + }, + { + "bbox": [ + 326, + 632, + 339, + 644 + ], + "score": 0.91, + "content": "f ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 633, + 506, + 645 + ], + "score": 1.0, + "content": "for each candidate, and then updates the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 644, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 106, + 644, + 505, + 656 + ], + "score": 1.0, + "content": "best observed policy. This is repeated for several iterations. A key property of this search method", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 654, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 387, + 668 + ], + "score": 1.0, + "content": "is that the progress is monotonic, so the reward of the returned policy", + "type": "text" + }, + { + "bbox": [ + 387, + 655, + 420, + 667 + ], + "score": 0.92, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 420, + 654, + 505, + 668 + ], + "score": 1.0, + "content": "will always improve", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 665, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 127, + 678 + ], + "score": 1.0, + "content": "over", + "type": "text" + }, + { + "bbox": [ + 128, + 666, + 134, + 676 + ], + "score": 0.69, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 134, + 665, + 505, + 678 + ], + "score": 1.0, + "content": ". This does not hold for the stochastic gradient operator, and appears to be beneficial on", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "some difficult problems (see Section 4.1). It has been claimed that hill climbing and other genetic", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "algorithms (Moriarty et al., 1999) are competitive with gradient-based methods for solving difficult", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 697, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 505, + 713 + ], + "score": 1.0, + "content": "RL tasks (Such et al., 2017; Risi & Stanley, 2019). Another stochastic algorithm approximating", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "local search is CMA-ES (Hansen et al., 2003; Igel, 2003; Krause et al., 2016), which performs more", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 721, + 410, + 734 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 410, + 734 + ], + "score": 1.0, + "content": "sophisticated search by adapting the covariance matrix of the perturbations.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 38.5 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 464, + 97 + ], + "score": 1.0, + "content": "This leads to the algorithm that we specify in Algorithm 3, where the adaptation operator", + "type": "text" + }, + { + "bbox": [ + 464, + 83, + 494, + 95 + ], + "score": 0.92, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 80, + 506, + 97 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 327, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 327, + 107 + ], + "score": 1.0, + "content": "itself estimated using the ES gradient in the inner loop.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 105, + 80, + 506, + 107 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 110, + 504, + 136 + ], + "lines": [ + { + "bbox": [ + 105, + 108, + 506, + 124 + ], + "spans": [ + { + "bbox": [ + 105, + 108, + 506, + 124 + ], + "score": 1.0, + "content": "We can also derive an algorithm analogous to PG-MAML by applying a first-order method to the", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 120, + 502, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 120, + 170, + 138 + ], + "score": 1.0, + "content": "MAML reward", + "type": "text" + }, + { + "bbox": [ + 170, + 121, + 285, + 137 + ], + "score": 0.92, + "content": "\\mathbb { E } _ { T \\sim \\mathcal { P } ( \\mathcal { T } ) } \\overline { { \\hat { f } ^ { T } } } ( \\theta + \\alpha \\nabla \\tilde { f } ^ { T } ( \\theta ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 286, + 120, + 502, + 138 + ], + "score": 1.0, + "content": "directly, without smoothing. The gradient is given by", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5, + "bbox_fs": [ + 105, + 108, + 506, + 138 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 186, + 146, + 424, + 164 + ], + "lines": [ + { + "bbox": [ + 186, + 146, + 424, + 164 + ], + "spans": [ + { + "bbox": [ + 186, + 146, + 424, + 164 + ], + "score": 0.89, + "content": "\\nabla J ( \\theta ) = \\mathbb { E } _ { T \\sim \\mathcal { P } ( \\mathcal { T } ) } \\nabla \\widetilde { f } ^ { T } ( \\theta + \\alpha \\nabla \\widetilde { f } ^ { T } ( \\theta ) ) ( \\mathbf { I } + \\alpha \\nabla ^ { 2 } \\widetilde { f } ^ { T } ( \\theta ) ) ,", + "type": "interline_equation", + "image_path": "6402d220c9be2f4c97dc7a0710f6709fb22c773f659786cd30b71009f4322997.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 186, + 146, + 424, + 164 + ], + "spans": [], + "index": 4 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 172, + 505, + 272 + ], + "lines": [ + { + "bbox": [ + 106, + 174, + 504, + 185 + ], + "spans": [ + { + "bbox": [ + 106, + 174, + 504, + 185 + ], + "score": 1.0, + "content": "which corresponds to equation (3) in (Liu et al., 2019) when expressed in terms of policy gradients.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 184, + 504, + 196 + ], + "spans": [ + { + "bbox": [ + 106, + 184, + 504, + 196 + ], + "score": 1.0, + "content": "Every term in this expression has a simple Monte Carlo estimator (see Algorithm 4 in the appendix", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 195, + 506, + 208 + ], + "spans": [ + { + "bbox": [ + 106, + 195, + 506, + 208 + ], + "score": 1.0, + "content": "for the MC Hessian estimator). We discuss this algorithm in greater detail in Appendix A.1. This", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 206, + 505, + 219 + ], + "spans": [ + { + "bbox": [ + 105, + 206, + 505, + 219 + ], + "score": 1.0, + "content": "formulation can be viewed as the “MAML of the smoothing”, compared to the “smoothing of the", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 216, + 506, + 230 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 506, + 230 + ], + "score": 1.0, + "content": "MAML” which is the basis for Algorithm 3. It is the additional smoothing present in equation 6", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 227, + 505, + 240 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 240, + 240 + ], + "score": 1.0, + "content": "which eliminates the gradient of", + "type": "text" + }, + { + "bbox": [ + 240, + 228, + 271, + 240 + ], + "score": 0.92, + "content": "U { \\bar { ( } } \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 227, + 383, + 240 + ], + "score": 1.0, + "content": "(and hence, the Hessian of", + "type": "text" + }, + { + "bbox": [ + 383, + 227, + 396, + 239 + ], + "score": 0.88, + "content": "f ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 227, + 505, + 240 + ], + "score": 1.0, + "content": "). Just as with the Hessian", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 238, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 106, + 238, + 505, + 252 + ], + "score": 1.0, + "content": "estimation in the original PG-MAML, we find empirically that the MC estimator of the Hessian", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 249, + 506, + 263 + ], + "spans": [ + { + "bbox": [ + 106, + 249, + 506, + 263 + ], + "score": 1.0, + "content": "(Algorithm 4) has high variance, making it often harmful in training. We present some comparisons", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 261, + 486, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 486, + 273 + ], + "score": 1.0, + "content": "between Algorithm 3 and Algorithm 5, with and without the Hessian term, in Appendix A.1.2.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 9, + "bbox_fs": [ + 105, + 174, + 506, + 273 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 279, + 503, + 313 + ], + "lines": [ + { + "bbox": [ + 106, + 277, + 505, + 292 + ], + "spans": [ + { + "bbox": [ + 106, + 279, + 169, + 292 + ], + "score": 1.0, + "content": "Note that when", + "type": "text" + }, + { + "bbox": [ + 170, + 280, + 201, + 291 + ], + "score": 0.92, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 279, + 455, + 292 + ], + "score": 1.0, + "content": "is estimated, such as in Algorithm 3, the resulting estimator for", + "type": "text" + }, + { + "bbox": [ + 455, + 277, + 475, + 291 + ], + "score": 0.92, + "content": "\\nabla \\mathcal { \\tilde { I } } _ { \\sigma }", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 279, + 505, + 292 + ], + "score": 1.0, + "content": "will in", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 290, + 505, + 303 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 505, + 303 + ], + "score": 1.0, + "content": "general be biased. This is similar to the estimator bias which occurs in PG-MAML because we do", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 302, + 504, + 314 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 504, + 314 + ], + "score": 1.0, + "content": "not have access to the true adapted trajectory distribution. We discuss this further in Appendix A.2.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 277, + 505, + 314 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 332, + 348, + 343 + ], + "lines": [ + { + "bbox": [ + 105, + 331, + 349, + 344 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 349, + 344 + ], + "score": 1.0, + "content": "3.3 IMPROVING THE ADAPTATION OPERATOR WITH ES", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 355, + 505, + 388 + ], + "lines": [ + { + "bbox": [ + 106, + 356, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 106, + 356, + 505, + 368 + ], + "score": 1.0, + "content": "Algorithm 2 allows for great flexibility in choosing new adaptation operators. The simplest extension", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 366, + 505, + 379 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 505, + 379 + ], + "score": 1.0, + "content": "is to modify the ES gradient step: we can draw on general techniques for improving the ES gradient", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 378, + 502, + 390 + ], + "spans": [ + { + "bbox": [ + 106, + 378, + 502, + 390 + ], + "score": 1.0, + "content": "estimator, some of which are described in Appendix A.3. Some other methods are explored below.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19, + "bbox_fs": [ + 105, + 356, + 505, + 390 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 407, + 249, + 418 + ], + "lines": [ + { + "bbox": [ + 105, + 406, + 251, + 419 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 251, + 419 + ], + "score": 1.0, + "content": "3.3.1 IMPROVED EXPLORATION", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 428, + 505, + 516 + ], + "lines": [ + { + "bbox": [ + 105, + 428, + 505, + 441 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 384, + 441 + ], + "score": 1.0, + "content": "Instead of using i.i.d Gaussian vectors to estimate the ES gradient in", + "type": "text" + }, + { + "bbox": [ + 384, + 428, + 415, + 441 + ], + "score": 0.93, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 429, + 505, + 441 + ], + "score": 1.0, + "content": ", we consider samples", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 439, + 505, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 505, + 452 + ], + "score": 1.0, + "content": "constructed according to Determinantal Point Processes (DPP). DPP sampling (Kulesza & Taskar,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 450, + 505, + 463 + ], + "spans": [ + { + "bbox": [ + 106, + 450, + 505, + 463 + ], + "score": 1.0, + "content": "2012; Wachinger & Golland, 2015) is a method of selecting a subset of samples so as to maximize", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 461, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 414, + 474 + ], + "score": 1.0, + "content": "the ‘diversity’ of the subset. It has been applied to ES to select perturbations", + "type": "text" + }, + { + "bbox": [ + 414, + 463, + 425, + 473 + ], + "score": 0.85, + "content": "\\mathbf { g } _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 461, + 505, + 474 + ], + "score": 1.0, + "content": "so that the gradient", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 473, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 505, + 484 + ], + "score": 1.0, + "content": "estimator has lower variance (Choromanski et al., 2019a). The sampling matrix determining DPP", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 482, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 506, + 496 + ], + "score": 1.0, + "content": "sampling can also be data-dependent and use information from the meta-training stage to construct", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 494, + 505, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 505, + 506 + ], + "score": 1.0, + "content": "a learned kernel with better properties for the adaptation phase. In the experimental section we show", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 505, + 339, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 339, + 518 + ], + "score": 1.0, + "content": "that DPP-ES can help in improving adaptation in MAML.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 25.5, + "bbox_fs": [ + 105, + 428, + 506, + 518 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 534, + 326, + 546 + ], + "lines": [ + { + "bbox": [ + 106, + 534, + 327, + 547 + ], + "spans": [ + { + "bbox": [ + 106, + 534, + 327, + 547 + ], + "score": 1.0, + "content": "3.3.2 HILL CLIMBING AND POPULATION SEARCH", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 107, + 556, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 555, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 220, + 569 + ], + "score": 1.0, + "content": "Nondifferentiable operators", + "type": "text" + }, + { + "bbox": [ + 221, + 556, + 252, + 568 + ], + "score": 0.93, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 555, + 505, + 569 + ], + "score": 1.0, + "content": "can be also used in Algorithm 2. One particularly interesting", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 567, + 505, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 301, + 580 + ], + "score": 1.0, + "content": "example is the local search operator given by", + "type": "text" + }, + { + "bbox": [ + 302, + 567, + 501, + 579 + ], + "score": 0.86, + "content": "U ( \\theta , T ) ~ \\stackrel { \\scriptscriptstyle = } { = } ~ \\mathrm { a r g m a x } \\{ f ^ { T } ( \\theta ^ { \\prime } ) ~ : ~ \\| \\theta ^ { \\prime } ~ \\stackrel { \\scriptscriptstyle < } { - } ~ \\theta \\| ~ \\le ~ R \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 567, + 505, + 580 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 577, + 506, + 591 + ], + "spans": [ + { + "bbox": [ + 106, + 577, + 133, + 591 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 578, + 162, + 588 + ], + "score": 0.9, + "content": "R > 0", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 577, + 281, + 591 + ], + "score": 1.0, + "content": "is the search radius. That is,", + "type": "text" + }, + { + "bbox": [ + 281, + 578, + 314, + 590 + ], + "score": 0.93, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 577, + 441, + 591 + ], + "score": 1.0, + "content": "selects the best policy for task", + "type": "text" + }, + { + "bbox": [ + 441, + 579, + 449, + 588 + ], + "score": 0.8, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 577, + 506, + 591 + ], + "score": 1.0, + "content": "which is in a", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 588, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 182, + 603 + ], + "score": 1.0, + "content": "‘neighborhood’ of", + "type": "text" + }, + { + "bbox": [ + 182, + 590, + 189, + 599 + ], + "score": 0.75, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 588, + 447, + 603 + ], + "score": 1.0, + "content": ". For simplicity, we took the search neighborhood to be the ball", + "type": "text" + }, + { + "bbox": [ + 447, + 589, + 481, + 601 + ], + "score": 0.93, + "content": "B ( \\theta , R )", + "type": "inline_equation" + }, + { + "bbox": [ + 481, + 588, + 506, + 603 + ], + "score": 1.0, + "content": "here,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 599, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 314, + 613 + ], + "score": 1.0, + "content": "but we may also use more general neighborhoods of", + "type": "text" + }, + { + "bbox": [ + 315, + 601, + 320, + 610 + ], + "score": 0.73, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 599, + 506, + 613 + ], + "score": 1.0, + "content": ". In general, exactly solving for the maximizer", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 104, + 609, + 506, + 625 + ], + "spans": [ + { + "bbox": [ + 104, + 609, + 117, + 625 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 117, + 610, + 130, + 623 + ], + "score": 0.91, + "content": "f ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 131, + 609, + 151, + 625 + ], + "score": 1.0, + "content": "over", + "type": "text" + }, + { + "bbox": [ + 151, + 611, + 185, + 623 + ], + "score": 0.93, + "content": "B ( \\theta , R )", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 609, + 506, + 625 + ], + "score": 1.0, + "content": "is intractable, but local search can often be well approximated by a hill climbing", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 622, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 106, + 622, + 505, + 635 + ], + "score": 1.0, + "content": "algorithm. Hill climbing creates a population of candidate policies by perturbing the best observed", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 632, + 506, + 645 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 227, + 645 + ], + "score": 1.0, + "content": "policy (which is initialized to", + "type": "text" + }, + { + "bbox": [ + 227, + 634, + 234, + 643 + ], + "score": 0.66, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 633, + 325, + 645 + ], + "score": 1.0, + "content": "), evaluates the reward", + "type": "text" + }, + { + "bbox": [ + 326, + 632, + 339, + 644 + ], + "score": 0.91, + "content": "f ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 633, + 506, + 645 + ], + "score": 1.0, + "content": "for each candidate, and then updates the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 644, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 106, + 644, + 505, + 656 + ], + "score": 1.0, + "content": "best observed policy. This is repeated for several iterations. A key property of this search method", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 654, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 387, + 668 + ], + "score": 1.0, + "content": "is that the progress is monotonic, so the reward of the returned policy", + "type": "text" + }, + { + "bbox": [ + 387, + 655, + 420, + 667 + ], + "score": 0.92, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 420, + 654, + 505, + 668 + ], + "score": 1.0, + "content": "will always improve", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 665, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 127, + 678 + ], + "score": 1.0, + "content": "over", + "type": "text" + }, + { + "bbox": [ + 128, + 666, + 134, + 676 + ], + "score": 0.69, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 134, + 665, + 505, + 678 + ], + "score": 1.0, + "content": ". This does not hold for the stochastic gradient operator, and appears to be beneficial on", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "some difficult problems (see Section 4.1). It has been claimed that hill climbing and other genetic", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "algorithms (Moriarty et al., 1999) are competitive with gradient-based methods for solving difficult", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 697, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 505, + 713 + ], + "score": 1.0, + "content": "RL tasks (Such et al., 2017; Risi & Stanley, 2019). Another stochastic algorithm approximating", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "local search is CMA-ES (Hansen et al., 2003; Igel, 2003; Krause et al., 2016), which performs more", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 721, + 410, + 734 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 410, + 734 + ], + "score": 1.0, + "content": "sophisticated search by adapting the covariance matrix of the perturbations.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 38.5, + "bbox_fs": [ + 104, + 555, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 111, + 115, + 496, + 225 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 107, + 89, + 504, + 112 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 89, + 505, + 102 + ], + "spans": [ + { + "bbox": [ + 106, + 89, + 505, + 102 + ], + "score": 1.0, + "content": "Figure 1: (a) ES-MAML and PG-MAML exploration behavior. (b) Different exploration methods", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 99, + 502, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 130, + 113 + ], + "score": 1.0, + "content": "when", + "type": "text" + }, + { + "bbox": [ + 131, + 101, + 141, + 110 + ], + "score": 0.8, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 99, + 185, + 113 + ], + "score": 1.0, + "content": "is limited", + "type": "text" + }, + { + "bbox": [ + 186, + 101, + 214, + 110 + ], + "score": 0.88, + "content": "K = 5", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 99, + 502, + 113 + ], + "score": 1.0, + "content": "plotted with lighter colors) or large penalties are added on wrong goals.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "image_body", + "bbox": [ + 111, + 115, + 496, + 225 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 111, + 115, + 496, + 225 + ], + "spans": [ + { + "bbox": [ + 111, + 115, + 496, + 225 + ], + "score": 0.959, + "type": "image", + "image_path": "5b77f59ea37c11d2933018aea788898ad3032a87ac6e81ebea970c6f43e0c40b.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 111, + 115, + 496, + 151.66666666666666 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 111, + 151.66666666666666, + 496, + 188.33333333333331 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 111, + 188.33333333333331, + 496, + 224.99999999999997 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 1.75 + }, + { + "type": "title", + "bbox": [ + 107, + 232, + 200, + 245 + ], + "lines": [ + { + "bbox": [ + 105, + 231, + 201, + 247 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 201, + 247 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 106, + 260, + 505, + 370 + ], + "lines": [ + { + "bbox": [ + 105, + 259, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 505, + 273 + ], + "score": 1.0, + "content": "The performance of MAML algorithms can be evaluated in several ways. One important measure", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "score": 1.0, + "content": "is the performance of the final meta-policy: whether the algorithm can consistently produce meta-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 282, + 505, + 294 + ], + "spans": [ + { + "bbox": [ + 106, + 282, + 505, + 294 + ], + "score": 1.0, + "content": "policies with better adaptation. In the RL setting, the adaptation of the meta-policy is also a function", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 293, + 506, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 167, + 306 + ], + "score": 1.0, + "content": "of the number", + "type": "text" + }, + { + "bbox": [ + 167, + 293, + 178, + 303 + ], + "score": 0.8, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 178, + 293, + 506, + 306 + ], + "score": 1.0, + "content": "of queries used: that is, the number of rollouts used by the adaptation operator", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 107, + 303, + 506, + 317 + ], + "spans": [ + { + "bbox": [ + 107, + 304, + 137, + 316 + ], + "score": 0.92, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 303, + 446, + 317 + ], + "score": 1.0, + "content": ". The meta-learning goal of data efficiency corresponds to adapting with low", + "type": "text" + }, + { + "bbox": [ + 447, + 304, + 457, + 314 + ], + "score": 0.73, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 303, + 506, + 317 + ], + "score": 1.0, + "content": ". The speed", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 315, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 505, + 327 + ], + "score": 1.0, + "content": "of the meta-training is also important, and can be measured in several ways: the number of meta-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 104, + 325, + 506, + 339 + ], + "spans": [ + { + "bbox": [ + 104, + 325, + 506, + 339 + ], + "score": 1.0, + "content": "policy updates, wall-clock time, and the number of rollouts used for meta-training. In this section,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 337, + 506, + 349 + ], + "spans": [ + { + "bbox": [ + 105, + 337, + 506, + 349 + ], + "score": 1.0, + "content": "we present experiments which evaluate various aspects of ES-MAML and PG-MAML in terms of", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 347, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 167, + 361 + ], + "score": 1.0, + "content": "data efficiency", + "type": "text" + }, + { + "bbox": [ + 167, + 348, + 183, + 359 + ], + "score": 0.7, + "content": "( K )", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 347, + 506, + 361 + ], + "score": 1.0, + "content": "and meta-training time. Further details of the environments and hyperparameters", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 359, + 218, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 218, + 371 + ], + "score": 1.0, + "content": "are given in Appendix A.7.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 107, + 376, + 505, + 518 + ], + "lines": [ + { + "bbox": [ + 106, + 376, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 505, + 388 + ], + "score": 1.0, + "content": "In the RL setting, the amount of information used drastically decreases if ES methods are applied in", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 386, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 505, + 400 + ], + "score": 1.0, + "content": "comparison to the PG setting. To be precise, ES uses only the cumulative reward over an episode,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "score": 1.0, + "content": "whereas policy gradients use every state-action pair. Intuitively, we may thus expect that ES should", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "score": 1.0, + "content": "have worse sampling complexity because it uses less information for the same number of rollouts.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 420, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 105, + 420, + 505, + 433 + ], + "score": 1.0, + "content": "However, it seems that in practice ES often matches or even exceeds policy gradients approaches", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 430, + 506, + 444 + ], + "spans": [ + { + "bbox": [ + 106, + 430, + 506, + 444 + ], + "score": 1.0, + "content": "(Salimans et al., 2017; Mania et al., 2018). Several explanations have been proposed: In the PG case,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 441, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 506, + 455 + ], + "score": 1.0, + "content": "especially with algorithms such as PPO, the network must optimize multiple additional surrogate", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 453, + 505, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 505, + 466 + ], + "score": 1.0, + "content": "objectives such as entropy bonuses and value functions as well as hyperparameters such as the TD-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 463, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 505, + 476 + ], + "score": 1.0, + "content": "step number. Furthermore, it has been argued that ES is more robust against delayed rewards, action", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 474, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 505, + 487 + ], + "score": 1.0, + "content": "infrequency, and long time horizons (Salimans et al., 2017). These advantages of ES in traditional", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 485, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 485, + 505, + 498 + ], + "score": 1.0, + "content": "RL also transfer to MAML, as we show empirically in this section. ES may lead to additional", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 496, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 496, + 505, + 509 + ], + "score": 1.0, + "content": "advantages (even if the numbers of rollouts needed in training is comparable with PG ones) in terms", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 506, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 505, + 520 + ], + "score": 1.0, + "content": "of wall-clock time, because it does not require backpropagation, and can be parallelized over CPUs.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 22 + }, + { + "type": "title", + "bbox": [ + 107, + 537, + 307, + 548 + ], + "lines": [ + { + "bbox": [ + 106, + 536, + 308, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 536, + 308, + 549 + ], + "score": 1.0, + "content": "4.1 EXPLORATION: TARGET ENVIRONMENTS", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 559, + 504, + 581 + ], + "lines": [ + { + "bbox": [ + 105, + 558, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 505, + 572 + ], + "score": 1.0, + "content": "In this section, we present two experiments on environments with very sparse rewards where the", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 570, + 438, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 570, + 438, + 582 + ], + "score": 1.0, + "content": "meta-policy must exhibit exploratory behavior to determine the correct adaptation.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5 + }, + { + "type": "text", + "bbox": [ + 107, + 587, + 505, + 729 + ], + "lines": [ + { + "bbox": [ + 106, + 586, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 586, + 505, + 599 + ], + "score": 1.0, + "content": "The four corners benchmark was introduced in (Rothfuss et al., 2019) to demonstrate the weak-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 598, + 505, + 610 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 505, + 610 + ], + "score": 1.0, + "content": "nesses of exploration in PG-MAML. An agent on a 2D square receives reward for moving towards", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 608, + 506, + 623 + ], + "spans": [ + { + "bbox": [ + 104, + 608, + 506, + 623 + ], + "score": 1.0, + "content": "a selected corner of the square, but only observes rewards once it is sufficiently close to the target", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 619, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 505, + 632 + ], + "score": 1.0, + "content": "corner, making the reward sparse. An effective exploration strategy for this set of tasks is for the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 631, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 631, + 156, + 643 + ], + "score": 1.0, + "content": "meta-policy", + "type": "text" + }, + { + "bbox": [ + 156, + 631, + 167, + 641 + ], + "score": 0.86, + "content": "\\theta ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 631, + 505, + 643 + ], + "score": 1.0, + "content": "to travel in circular trajectories to observe which corner produces rewards; however,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "score": 1.0, + "content": "for a single policy to produce this exploration behavior is difficult. In Figure 1, we demonstrate the", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 652, + 506, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 350, + 666 + ], + "score": 1.0, + "content": "behavior of ES-MAML on the four corners problem. When", + "type": "text" + }, + { + "bbox": [ + 350, + 653, + 385, + 663 + ], + "score": 0.9, + "content": "K = 2 0", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 652, + 506, + 666 + ], + "score": 1.0, + "content": ", the same number of rollouts", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 663, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 505, + 677 + ], + "score": 1.0, + "content": "for adaptation as used in (Rothfuss et al., 2019), the basic version of Algorithm 3 is able to correctly", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 675, + 505, + 688 + ], + "spans": [ + { + "bbox": [ + 105, + 675, + 505, + 688 + ], + "score": 1.0, + "content": "explore and adapt to the task by finding the target corner. Moreover, it does not require any modifi-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 685, + 505, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 685, + 387, + 698 + ], + "score": 1.0, + "content": "cations to encourage exploration, unlike PG-MAML. We further used", + "type": "text" + }, + { + "bbox": [ + 387, + 686, + 430, + 697 + ], + "score": 0.9, + "content": "K = 1 0 , 5", + "type": "inline_equation" + }, + { + "bbox": [ + 430, + 685, + 505, + 698 + ], + "score": 1.0, + "content": ", which caused the", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 696, + 505, + 709 + ], + "spans": [ + { + "bbox": [ + 105, + 696, + 505, + 709 + ], + "score": 1.0, + "content": "performance to drop. For better performance in this low-information environment, we experimented", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 707, + 505, + 720 + ], + "spans": [ + { + "bbox": [ + 105, + 707, + 268, + 720 + ], + "score": 1.0, + "content": "with two different adaptation operators", + "type": "text" + }, + { + "bbox": [ + 268, + 709, + 298, + 720 + ], + "score": 0.93, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 299, + 707, + 505, + 720 + ], + "score": 1.0, + "content": "in Algorithm 2, which are HC (hill climbing) and", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 718, + 311, + 731 + ], + "spans": [ + { + "bbox": [ + 105, + 718, + 311, + 731 + ], + "score": 1.0, + "content": "DPP-ES. The standard ES gradient is denoted MC.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 38 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 111, + 115, + 496, + 225 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 107, + 89, + 504, + 112 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 89, + 505, + 102 + ], + "spans": [ + { + "bbox": [ + 106, + 89, + 505, + 102 + ], + "score": 1.0, + "content": "Figure 1: (a) ES-MAML and PG-MAML exploration behavior. (b) Different exploration methods", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 99, + 502, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 130, + 113 + ], + "score": 1.0, + "content": "when", + "type": "text" + }, + { + "bbox": [ + 131, + 101, + 141, + 110 + ], + "score": 0.8, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 99, + 185, + 113 + ], + "score": 1.0, + "content": "is limited", + "type": "text" + }, + { + "bbox": [ + 186, + 101, + 214, + 110 + ], + "score": 0.88, + "content": "K = 5", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 99, + 502, + 113 + ], + "score": 1.0, + "content": "plotted with lighter colors) or large penalties are added on wrong goals.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "image_body", + "bbox": [ + 111, + 115, + 496, + 225 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 111, + 115, + 496, + 225 + ], + "spans": [ + { + "bbox": [ + 111, + 115, + 496, + 225 + ], + "score": 0.959, + "type": "image", + "image_path": "5b77f59ea37c11d2933018aea788898ad3032a87ac6e81ebea970c6f43e0c40b.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 111, + 115, + 496, + 151.66666666666666 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 111, + 151.66666666666666, + 496, + 188.33333333333331 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 111, + 188.33333333333331, + 496, + 224.99999999999997 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 1.75 + }, + { + "type": "title", + "bbox": [ + 107, + 232, + 200, + 245 + ], + "lines": [ + { + "bbox": [ + 105, + 231, + 201, + 247 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 201, + 247 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 106, + 260, + 505, + 370 + ], + "lines": [ + { + "bbox": [ + 105, + 259, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 505, + 273 + ], + "score": 1.0, + "content": "The performance of MAML algorithms can be evaluated in several ways. One important measure", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "score": 1.0, + "content": "is the performance of the final meta-policy: whether the algorithm can consistently produce meta-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 282, + 505, + 294 + ], + "spans": [ + { + "bbox": [ + 106, + 282, + 505, + 294 + ], + "score": 1.0, + "content": "policies with better adaptation. In the RL setting, the adaptation of the meta-policy is also a function", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 293, + 506, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 167, + 306 + ], + "score": 1.0, + "content": "of the number", + "type": "text" + }, + { + "bbox": [ + 167, + 293, + 178, + 303 + ], + "score": 0.8, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 178, + 293, + 506, + 306 + ], + "score": 1.0, + "content": "of queries used: that is, the number of rollouts used by the adaptation operator", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 107, + 303, + 506, + 317 + ], + "spans": [ + { + "bbox": [ + 107, + 304, + 137, + 316 + ], + "score": 0.92, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 303, + 446, + 317 + ], + "score": 1.0, + "content": ". The meta-learning goal of data efficiency corresponds to adapting with low", + "type": "text" + }, + { + "bbox": [ + 447, + 304, + 457, + 314 + ], + "score": 0.73, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 303, + 506, + 317 + ], + "score": 1.0, + "content": ". The speed", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 315, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 505, + 327 + ], + "score": 1.0, + "content": "of the meta-training is also important, and can be measured in several ways: the number of meta-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 104, + 325, + 506, + 339 + ], + "spans": [ + { + "bbox": [ + 104, + 325, + 506, + 339 + ], + "score": 1.0, + "content": "policy updates, wall-clock time, and the number of rollouts used for meta-training. In this section,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 337, + 506, + 349 + ], + "spans": [ + { + "bbox": [ + 105, + 337, + 506, + 349 + ], + "score": 1.0, + "content": "we present experiments which evaluate various aspects of ES-MAML and PG-MAML in terms of", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 347, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 167, + 361 + ], + "score": 1.0, + "content": "data efficiency", + "type": "text" + }, + { + "bbox": [ + 167, + 348, + 183, + 359 + ], + "score": 0.7, + "content": "( K )", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 347, + 506, + 361 + ], + "score": 1.0, + "content": "and meta-training time. Further details of the environments and hyperparameters", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 359, + 218, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 218, + 371 + ], + "score": 1.0, + "content": "are given in Appendix A.7.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 10.5, + "bbox_fs": [ + 104, + 259, + 506, + 371 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 376, + 505, + 518 + ], + "lines": [ + { + "bbox": [ + 106, + 376, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 505, + 388 + ], + "score": 1.0, + "content": "In the RL setting, the amount of information used drastically decreases if ES methods are applied in", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 386, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 505, + 400 + ], + "score": 1.0, + "content": "comparison to the PG setting. To be precise, ES uses only the cumulative reward over an episode,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "score": 1.0, + "content": "whereas policy gradients use every state-action pair. Intuitively, we may thus expect that ES should", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "score": 1.0, + "content": "have worse sampling complexity because it uses less information for the same number of rollouts.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 420, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 105, + 420, + 505, + 433 + ], + "score": 1.0, + "content": "However, it seems that in practice ES often matches or even exceeds policy gradients approaches", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 430, + 506, + 444 + ], + "spans": [ + { + "bbox": [ + 106, + 430, + 506, + 444 + ], + "score": 1.0, + "content": "(Salimans et al., 2017; Mania et al., 2018). Several explanations have been proposed: In the PG case,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 441, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 506, + 455 + ], + "score": 1.0, + "content": "especially with algorithms such as PPO, the network must optimize multiple additional surrogate", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 453, + 505, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 505, + 466 + ], + "score": 1.0, + "content": "objectives such as entropy bonuses and value functions as well as hyperparameters such as the TD-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 463, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 505, + 476 + ], + "score": 1.0, + "content": "step number. Furthermore, it has been argued that ES is more robust against delayed rewards, action", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 474, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 505, + 487 + ], + "score": 1.0, + "content": "infrequency, and long time horizons (Salimans et al., 2017). These advantages of ES in traditional", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 485, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 485, + 505, + 498 + ], + "score": 1.0, + "content": "RL also transfer to MAML, as we show empirically in this section. ES may lead to additional", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 496, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 496, + 505, + 509 + ], + "score": 1.0, + "content": "advantages (even if the numbers of rollouts needed in training is comparable with PG ones) in terms", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 506, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 505, + 520 + ], + "score": 1.0, + "content": "of wall-clock time, because it does not require backpropagation, and can be parallelized over CPUs.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 22, + "bbox_fs": [ + 105, + 376, + 506, + 520 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 537, + 307, + 548 + ], + "lines": [ + { + "bbox": [ + 106, + 536, + 308, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 536, + 308, + 549 + ], + "score": 1.0, + "content": "4.1 EXPLORATION: TARGET ENVIRONMENTS", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 559, + 504, + 581 + ], + "lines": [ + { + "bbox": [ + 105, + 558, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 505, + 572 + ], + "score": 1.0, + "content": "In this section, we present two experiments on environments with very sparse rewards where the", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 570, + 438, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 570, + 438, + 582 + ], + "score": 1.0, + "content": "meta-policy must exhibit exploratory behavior to determine the correct adaptation.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 558, + 505, + 582 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 587, + 505, + 729 + ], + "lines": [ + { + "bbox": [ + 106, + 586, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 586, + 505, + 599 + ], + "score": 1.0, + "content": "The four corners benchmark was introduced in (Rothfuss et al., 2019) to demonstrate the weak-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 598, + 505, + 610 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 505, + 610 + ], + "score": 1.0, + "content": "nesses of exploration in PG-MAML. An agent on a 2D square receives reward for moving towards", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 608, + 506, + 623 + ], + "spans": [ + { + "bbox": [ + 104, + 608, + 506, + 623 + ], + "score": 1.0, + "content": "a selected corner of the square, but only observes rewards once it is sufficiently close to the target", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 619, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 505, + 632 + ], + "score": 1.0, + "content": "corner, making the reward sparse. An effective exploration strategy for this set of tasks is for the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 631, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 631, + 156, + 643 + ], + "score": 1.0, + "content": "meta-policy", + "type": "text" + }, + { + "bbox": [ + 156, + 631, + 167, + 641 + ], + "score": 0.86, + "content": "\\theta ^ { * }", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 631, + 505, + 643 + ], + "score": 1.0, + "content": "to travel in circular trajectories to observe which corner produces rewards; however,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "score": 1.0, + "content": "for a single policy to produce this exploration behavior is difficult. In Figure 1, we demonstrate the", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 652, + 506, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 350, + 666 + ], + "score": 1.0, + "content": "behavior of ES-MAML on the four corners problem. When", + "type": "text" + }, + { + "bbox": [ + 350, + 653, + 385, + 663 + ], + "score": 0.9, + "content": "K = 2 0", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 652, + 506, + 666 + ], + "score": 1.0, + "content": ", the same number of rollouts", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 663, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 505, + 677 + ], + "score": 1.0, + "content": "for adaptation as used in (Rothfuss et al., 2019), the basic version of Algorithm 3 is able to correctly", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 675, + 505, + 688 + ], + "spans": [ + { + "bbox": [ + 105, + 675, + 505, + 688 + ], + "score": 1.0, + "content": "explore and adapt to the task by finding the target corner. Moreover, it does not require any modifi-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 685, + 505, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 685, + 387, + 698 + ], + "score": 1.0, + "content": "cations to encourage exploration, unlike PG-MAML. We further used", + "type": "text" + }, + { + "bbox": [ + 387, + 686, + 430, + 697 + ], + "score": 0.9, + "content": "K = 1 0 , 5", + "type": "inline_equation" + }, + { + "bbox": [ + 430, + 685, + 505, + 698 + ], + "score": 1.0, + "content": ", which caused the", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 696, + 505, + 709 + ], + "spans": [ + { + "bbox": [ + 105, + 696, + 505, + 709 + ], + "score": 1.0, + "content": "performance to drop. For better performance in this low-information environment, we experimented", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 707, + 505, + 720 + ], + "spans": [ + { + "bbox": [ + 105, + 707, + 268, + 720 + ], + "score": 1.0, + "content": "with two different adaptation operators", + "type": "text" + }, + { + "bbox": [ + 268, + 709, + 298, + 720 + ], + "score": 0.93, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 299, + 707, + 505, + 720 + ], + "score": 1.0, + "content": "in Algorithm 2, which are HC (hill climbing) and", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 718, + 311, + 731 + ], + "spans": [ + { + "bbox": [ + 105, + 718, + 311, + 731 + ], + "score": 1.0, + "content": "DPP-ES. The standard ES gradient is denoted MC.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 38, + "bbox_fs": [ + 104, + 586, + 506, + 731 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 505, + 148 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Furthermore, ES-MAML is not limited to “single goal” exploration. We created a more difficult", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 506, + 106 + ], + "score": 1.0, + "content": "task, six circles, where the agent continuously accrues negative rewards until it reaches six target", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 506, + 118 + ], + "score": 1.0, + "content": "points to “deactivate” them. Solving this task requires the agent to explore in circular trajectories,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "score": 1.0, + "content": "similar to the trajectory used by PG-MAML on the four corners task. We visualize the behavior in", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 506, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 506, + 139 + ], + "score": 1.0, + "content": "Figure 2. Observe that ES-MAML with the HC operator is able to develop a strategy to explore the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 137, + 172, + 149 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 172, + 149 + ], + "score": 1.0, + "content": "target locations.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5 + }, + { + "type": "image", + "bbox": [ + 109, + 182, + 304, + 284 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 106, + 156, + 306, + 178 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 156, + 307, + 169 + ], + "spans": [ + { + "bbox": [ + 106, + 156, + 307, + 169 + ], + "score": 1.0, + "content": "Figure 2: ES-MAML exploration on six circle", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 167, + 170, + 181 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 128, + 181 + ], + "score": 1.0, + "content": "task", + "type": "text" + }, + { + "bbox": [ + 128, + 168, + 163, + 178 + ], + "score": 0.86, + "content": "K = 2 0", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 167, + 170, + 181 + ], + "score": 1.0, + "content": ").", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5 + }, + { + "type": "image_body", + "bbox": [ + 109, + 182, + 304, + 284 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 182, + 304, + 284 + ], + "spans": [ + { + "bbox": [ + 109, + 182, + 304, + 284 + ], + "score": 0.957, + "type": "image", + "image_path": "8fa5d0f0176bb5b94749567589e0fb1f6245dea2259a70bf70180cbfc661f6fe.jpg" + } + ] + } + ], + "index": 11.5, + "virtual_lines": [ + { + "bbox": [ + 109, + 182, + 304, + 194.75 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 109, + 194.75, + 304, + 207.5 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 109, + 207.5, + 304, + 220.25 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 109, + 220.25, + 304, + 233.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 109, + 233.0, + 304, + 245.75 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 109, + 245.75, + 304, + 258.5 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 109, + 258.5, + 304, + 271.25 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 109, + 271.25, + 304, + 284.0 + ], + "spans": [], + "index": 15 + } + ] + } + ], + "index": 9.0 + }, + { + "type": "text", + "bbox": [ + 315, + 154, + 504, + 285 + ], + "lines": [ + { + "bbox": [ + 314, + 154, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 314, + 154, + 505, + 167 + ], + "score": 1.0, + "content": "From Figure 1, we observed that both oper-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 314, + 165, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 314, + 165, + 505, + 177 + ], + "score": 1.0, + "content": "ators DPP-ES and HC were able to improve", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 313, + 176, + 505, + 188 + ], + "spans": [ + { + "bbox": [ + 313, + 176, + 505, + 188 + ], + "score": 1.0, + "content": "exploration performance. We also created a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 314, + 187, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 314, + 187, + 505, + 199 + ], + "score": 1.0, + "content": "modified task by heavily penalizing incorrect", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 313, + 198, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 313, + 198, + 505, + 210 + ], + "score": 1.0, + "content": "goals, which caused performance to dramati-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 314, + 209, + 505, + 221 + ], + "spans": [ + { + "bbox": [ + 314, + 209, + 505, + 221 + ], + "score": 1.0, + "content": "cally drop for MC and DPP-ES. This is due to", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 313, + 219, + 505, + 233 + ], + "spans": [ + { + "bbox": [ + 313, + 219, + 505, + 233 + ], + "score": 1.0, + "content": "the variance from the MC-gradient, which may", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 313, + 231, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 313, + 231, + 505, + 243 + ], + "score": 1.0, + "content": "result in a adapted policy that accidentally pro-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 314, + 242, + 505, + 253 + ], + "spans": [ + { + "bbox": [ + 314, + 242, + 505, + 253 + ], + "score": 1.0, + "content": "duces large negative rewards or become stuck", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 314, + 253, + 505, + 264 + ], + "spans": [ + { + "bbox": [ + 314, + 253, + 505, + 264 + ], + "score": 1.0, + "content": "in local-optima (i.e. refuse to explore due to", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 314, + 264, + 505, + 276 + ], + "spans": [ + { + "bbox": [ + 314, + 264, + 505, + 276 + ], + "score": 1.0, + "content": "negative rewards). This is also fixed by the HC", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 314, + 275, + 505, + 287 + ], + "spans": [ + { + "bbox": [ + 314, + 275, + 505, + 287 + ], + "score": 1.0, + "content": "adaptation, which enforces non-decreasing re-", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 21.5 + }, + { + "type": "text", + "bbox": [ + 107, + 286, + 356, + 297 + ], + "lines": [ + { + "bbox": [ + 105, + 284, + 357, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 357, + 300 + ], + "score": 1.0, + "content": "wards during adaptation, allowing the ES-MAML to progress.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 108, + 303, + 504, + 325 + ], + "lines": [ + { + "bbox": [ + 106, + 302, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 505, + 316 + ], + "score": 1.0, + "content": "Additional examples on the classic Navigation-2D task are presented in Appendix A.4, highlighting", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 314, + 415, + 325 + ], + "spans": [ + { + "bbox": [ + 106, + 314, + 415, + 325 + ], + "score": 1.0, + "content": "the differences in exploration behavior between PG-MAML and ES-MAML.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5 + }, + { + "type": "title", + "bbox": [ + 107, + 341, + 362, + 353 + ], + "lines": [ + { + "bbox": [ + 106, + 340, + 363, + 354 + ], + "spans": [ + { + "bbox": [ + 106, + 340, + 363, + 354 + ], + "score": 1.0, + "content": "4.2 GOOD ADAPTATION WITH COMPACT ARCHITECTURES", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 106, + 362, + 505, + 462 + ], + "lines": [ + { + "bbox": [ + 105, + 362, + 506, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 506, + 376 + ], + "score": 1.0, + "content": "One of the main benefits of ES is due to its ability to train compact linear policies, which can", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 374, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 106, + 374, + 505, + 386 + ], + "score": 1.0, + "content": "outperform hidden-layer policies. We demonstrate this on several benchmark MAML problems in", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 384, + 506, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 506, + 398 + ], + "score": 1.0, + "content": "the HalfCheetah and Ant environments in Figure 3. In contrast, (Finn & Levine, 2018) observed", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 395, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 505, + 408 + ], + "score": 1.0, + "content": "that PG-MAML empirically and theoretically suggested that training with more deeper layers under", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 406, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 505, + 420 + ], + "score": 1.0, + "content": "SGD increases performance. We demonstrate that on the Forward-Backward and Goal-Velocity", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 417, + 505, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 417, + 505, + 430 + ], + "score": 1.0, + "content": "MAML benchmarks, ES-MAML is consistently able to train successful linear policies faster than", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 429, + 506, + 441 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 506, + 441 + ], + "score": 1.0, + "content": "deep networks. We also show that, for the Forward-Backward Ant problem, ES-MAML with the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 438, + 505, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 438, + 505, + 454 + ], + "score": 1.0, + "content": "new HC operator is the most performant. Using more compact policies also directly speeds up", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 451, + 401, + 463 + ], + "spans": [ + { + "bbox": [ + 106, + 451, + 401, + 463 + ], + "score": 1.0, + "content": "ES-MAML, since fewer perturbations are needed for gradient estimation.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 36 + }, + { + "type": "image", + "bbox": [ + 114, + 506, + 496, + 598 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 106, + 483, + 501, + 506 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 484, + 503, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 503, + 496 + ], + "score": 1.0, + "content": "Figure 3: The Forward-Backward and Goal-Velocity MAML problems. We compare the perfor-", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 494, + 447, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 433, + 507 + ], + "score": 1.0, + "content": "mance for Linear (L) policies and policies with one hidden layer (H) for different", + "type": "text" + }, + { + "bbox": [ + 433, + 495, + 443, + 505 + ], + "score": 0.64, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 443, + 494, + 447, + 507 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + }, + { + "type": "image_body", + "bbox": [ + 114, + 506, + 496, + 598 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 114, + 506, + 496, + 598 + ], + "spans": [ + { + "bbox": [ + 114, + 506, + 496, + 598 + ], + "score": 0.945, + "type": "image", + "image_path": "cbb5a4cbd49afd91a97672d25c0c17c04de7ca7c0d13bd7dd8f2092c02d0b049.jpg" + } + ] + } + ], + "index": 44, + "virtual_lines": [ + { + "bbox": [ + 114, + 506, + 496, + 536.6666666666666 + ], + "spans": [], + "index": 43 + }, + { + "bbox": [ + 114, + 536.6666666666666, + 496, + 567.3333333333333 + ], + "spans": [], + "index": 44 + }, + { + "bbox": [ + 114, + 567.3333333333333, + 496, + 597.9999999999999 + ], + "spans": [], + "index": 45 + } + ] + } + ], + "index": 42.75 + }, + { + "type": "title", + "bbox": [ + 107, + 622, + 243, + 633 + ], + "lines": [ + { + "bbox": [ + 106, + 622, + 244, + 634 + ], + "spans": [ + { + "bbox": [ + 106, + 622, + 244, + 634 + ], + "score": 1.0, + "content": "4.3 DETERMINISTIC POLICIES", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 46 + }, + { + "type": "text", + "bbox": [ + 106, + 643, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 107, + 644, + 505, + 655 + ], + "spans": [ + { + "bbox": [ + 107, + 644, + 505, + 655 + ], + "score": 1.0, + "content": "We find that deterministic policies often produce more stable behaviors than the stochastic ones that", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "are required for PG, where randomized actions in unstable environments can lead to catastrophic", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "outcomes. In PG, this is often mitigated by reducing the entropy bonus, but this has an undesirable", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "side effect of reducing exploration. In contrast, ES-MAML explores in parameter space, which", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "mitigates this issue. To demonstrate this, we use the “Biased-Sensor CartPole” environment from", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "(Yang et al., 2019). This environment has unstable dynamics and sparse rewards, so it requires", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "exploration but is also risky. We see in Figure 4 that ES-MAML is able to stably maintain the", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 106, + 720, + 205, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 205, + 732 + ], + "score": 1.0, + "content": "maximum reward (500).", + "type": "text" + } + ], + "index": 54 + } + ], + "index": 50.5 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 303, + 751, + 309, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 505, + 148 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Furthermore, ES-MAML is not limited to “single goal” exploration. We created a more difficult", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 506, + 106 + ], + "score": 1.0, + "content": "task, six circles, where the agent continuously accrues negative rewards until it reaches six target", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 506, + 118 + ], + "score": 1.0, + "content": "points to “deactivate” them. Solving this task requires the agent to explore in circular trajectories,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "score": 1.0, + "content": "similar to the trajectory used by PG-MAML on the four corners task. We visualize the behavior in", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 506, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 506, + 139 + ], + "score": 1.0, + "content": "Figure 2. Observe that ES-MAML with the HC operator is able to develop a strategy to explore the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 137, + 172, + 149 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 172, + 149 + ], + "score": 1.0, + "content": "target locations.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5, + "bbox_fs": [ + 105, + 82, + 506, + 149 + ] + }, + { + "type": "image", + "bbox": [ + 109, + 182, + 304, + 284 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 106, + 156, + 306, + 178 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 156, + 307, + 169 + ], + "spans": [ + { + "bbox": [ + 106, + 156, + 307, + 169 + ], + "score": 1.0, + "content": "Figure 2: ES-MAML exploration on six circle", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 167, + 170, + 181 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 128, + 181 + ], + "score": 1.0, + "content": "task", + "type": "text" + }, + { + "bbox": [ + 128, + 168, + 163, + 178 + ], + "score": 0.86, + "content": "K = 2 0", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 167, + 170, + 181 + ], + "score": 1.0, + "content": ").", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5 + }, + { + "type": "image_body", + "bbox": [ + 109, + 182, + 304, + 284 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 182, + 304, + 284 + ], + "spans": [ + { + "bbox": [ + 109, + 182, + 304, + 284 + ], + "score": 0.957, + "type": "image", + "image_path": "8fa5d0f0176bb5b94749567589e0fb1f6245dea2259a70bf70180cbfc661f6fe.jpg" + } + ] + } + ], + "index": 11.5, + "virtual_lines": [ + { + "bbox": [ + 109, + 182, + 304, + 194.75 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 109, + 194.75, + 304, + 207.5 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 109, + 207.5, + 304, + 220.25 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 109, + 220.25, + 304, + 233.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 109, + 233.0, + 304, + 245.75 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 109, + 245.75, + 304, + 258.5 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 109, + 258.5, + 304, + 271.25 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 109, + 271.25, + 304, + 284.0 + ], + "spans": [], + "index": 15 + } + ] + } + ], + "index": 9.0 + }, + { + "type": "text", + "bbox": [ + 315, + 154, + 504, + 285 + ], + "lines": [ + { + "bbox": [ + 314, + 154, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 314, + 154, + 505, + 167 + ], + "score": 1.0, + "content": "From Figure 1, we observed that both oper-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 314, + 165, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 314, + 165, + 505, + 177 + ], + "score": 1.0, + "content": "ators DPP-ES and HC were able to improve", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 313, + 176, + 505, + 188 + ], + "spans": [ + { + "bbox": [ + 313, + 176, + 505, + 188 + ], + "score": 1.0, + "content": "exploration performance. We also created a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 314, + 187, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 314, + 187, + 505, + 199 + ], + "score": 1.0, + "content": "modified task by heavily penalizing incorrect", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 313, + 198, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 313, + 198, + 505, + 210 + ], + "score": 1.0, + "content": "goals, which caused performance to dramati-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 314, + 209, + 505, + 221 + ], + "spans": [ + { + "bbox": [ + 314, + 209, + 505, + 221 + ], + "score": 1.0, + "content": "cally drop for MC and DPP-ES. This is due to", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 313, + 219, + 505, + 233 + ], + "spans": [ + { + "bbox": [ + 313, + 219, + 505, + 233 + ], + "score": 1.0, + "content": "the variance from the MC-gradient, which may", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 313, + 231, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 313, + 231, + 505, + 243 + ], + "score": 1.0, + "content": "result in a adapted policy that accidentally pro-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 314, + 242, + 505, + 253 + ], + "spans": [ + { + "bbox": [ + 314, + 242, + 505, + 253 + ], + "score": 1.0, + "content": "duces large negative rewards or become stuck", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 314, + 253, + 505, + 264 + ], + "spans": [ + { + "bbox": [ + 314, + 253, + 505, + 264 + ], + "score": 1.0, + "content": "in local-optima (i.e. refuse to explore due to", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 314, + 264, + 505, + 276 + ], + "spans": [ + { + "bbox": [ + 314, + 264, + 505, + 276 + ], + "score": 1.0, + "content": "negative rewards). This is also fixed by the HC", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 314, + 275, + 505, + 287 + ], + "spans": [ + { + "bbox": [ + 314, + 275, + 505, + 287 + ], + "score": 1.0, + "content": "adaptation, which enforces non-decreasing re-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 284, + 357, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 357, + 300 + ], + "score": 1.0, + "content": "wards during adaptation, allowing the ES-MAML to progress.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 21.5, + "bbox_fs": [ + 313, + 154, + 505, + 287 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 286, + 356, + 297 + ], + "lines": [], + "index": 28, + "bbox_fs": [ + 105, + 284, + 357, + 300 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 108, + 303, + 504, + 325 + ], + "lines": [ + { + "bbox": [ + 106, + 302, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 505, + 316 + ], + "score": 1.0, + "content": "Additional examples on the classic Navigation-2D task are presented in Appendix A.4, highlighting", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 314, + 415, + 325 + ], + "spans": [ + { + "bbox": [ + 106, + 314, + 415, + 325 + ], + "score": 1.0, + "content": "the differences in exploration behavior between PG-MAML and ES-MAML.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5, + "bbox_fs": [ + 106, + 302, + 505, + 325 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 341, + 362, + 353 + ], + "lines": [ + { + "bbox": [ + 106, + 340, + 363, + 354 + ], + "spans": [ + { + "bbox": [ + 106, + 340, + 363, + 354 + ], + "score": 1.0, + "content": "4.2 GOOD ADAPTATION WITH COMPACT ARCHITECTURES", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 106, + 362, + 505, + 462 + ], + "lines": [ + { + "bbox": [ + 105, + 362, + 506, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 506, + 376 + ], + "score": 1.0, + "content": "One of the main benefits of ES is due to its ability to train compact linear policies, which can", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 374, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 106, + 374, + 505, + 386 + ], + "score": 1.0, + "content": "outperform hidden-layer policies. We demonstrate this on several benchmark MAML problems in", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 384, + 506, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 506, + 398 + ], + "score": 1.0, + "content": "the HalfCheetah and Ant environments in Figure 3. In contrast, (Finn & Levine, 2018) observed", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 395, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 505, + 408 + ], + "score": 1.0, + "content": "that PG-MAML empirically and theoretically suggested that training with more deeper layers under", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 406, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 505, + 420 + ], + "score": 1.0, + "content": "SGD increases performance. We demonstrate that on the Forward-Backward and Goal-Velocity", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 417, + 505, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 417, + 505, + 430 + ], + "score": 1.0, + "content": "MAML benchmarks, ES-MAML is consistently able to train successful linear policies faster than", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 429, + 506, + 441 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 506, + 441 + ], + "score": 1.0, + "content": "deep networks. We also show that, for the Forward-Backward Ant problem, ES-MAML with the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 438, + 505, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 438, + 505, + 454 + ], + "score": 1.0, + "content": "new HC operator is the most performant. Using more compact policies also directly speeds up", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 451, + 401, + 463 + ], + "spans": [ + { + "bbox": [ + 106, + 451, + 401, + 463 + ], + "score": 1.0, + "content": "ES-MAML, since fewer perturbations are needed for gradient estimation.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 36, + "bbox_fs": [ + 105, + 362, + 506, + 463 + ] + }, + { + "type": "image", + "bbox": [ + 114, + 506, + 496, + 598 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 106, + 483, + 501, + 506 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 484, + 503, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 503, + 496 + ], + "score": 1.0, + "content": "Figure 3: The Forward-Backward and Goal-Velocity MAML problems. We compare the perfor-", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 494, + 447, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 433, + 507 + ], + "score": 1.0, + "content": "mance for Linear (L) policies and policies with one hidden layer (H) for different", + "type": "text" + }, + { + "bbox": [ + 433, + 495, + 443, + 505 + ], + "score": 0.64, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 443, + 494, + 447, + 507 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + }, + { + "type": "image_body", + "bbox": [ + 114, + 506, + 496, + 598 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 114, + 506, + 496, + 598 + ], + "spans": [ + { + "bbox": [ + 114, + 506, + 496, + 598 + ], + "score": 0.945, + "type": "image", + "image_path": "cbb5a4cbd49afd91a97672d25c0c17c04de7ca7c0d13bd7dd8f2092c02d0b049.jpg" + } + ] + } + ], + "index": 44, + "virtual_lines": [ + { + "bbox": [ + 114, + 506, + 496, + 536.6666666666666 + ], + "spans": [], + "index": 43 + }, + { + "bbox": [ + 114, + 536.6666666666666, + 496, + 567.3333333333333 + ], + "spans": [], + "index": 44 + }, + { + "bbox": [ + 114, + 567.3333333333333, + 496, + 597.9999999999999 + ], + "spans": [], + "index": 45 + } + ] + } + ], + "index": 42.75 + }, + { + "type": "title", + "bbox": [ + 107, + 622, + 243, + 633 + ], + "lines": [ + { + "bbox": [ + 106, + 622, + 244, + 634 + ], + "spans": [ + { + "bbox": [ + 106, + 622, + 244, + 634 + ], + "score": 1.0, + "content": "4.3 DETERMINISTIC POLICIES", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 46 + }, + { + "type": "text", + "bbox": [ + 106, + 643, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 107, + 644, + 505, + 655 + ], + "spans": [ + { + "bbox": [ + 107, + 644, + 505, + 655 + ], + "score": 1.0, + "content": "We find that deterministic policies often produce more stable behaviors than the stochastic ones that", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "are required for PG, where randomized actions in unstable environments can lead to catastrophic", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "outcomes. In PG, this is often mitigated by reducing the entropy bonus, but this has an undesirable", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "side effect of reducing exploration. In contrast, ES-MAML explores in parameter space, which", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "mitigates this issue. To demonstrate this, we use the “Biased-Sensor CartPole” environment from", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "(Yang et al., 2019). This environment has unstable dynamics and sparse rewards, so it requires", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "exploration but is also risky. We see in Figure 4 that ES-MAML is able to stably maintain the", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 106, + 720, + 205, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 205, + 732 + ], + "score": 1.0, + "content": "maximum reward (500).", + "type": "text" + } + ], + "index": 54 + } + ], + "index": 50.5, + "bbox_fs": [ + 105, + 644, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 110, + 113, + 500, + 208 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 106, + 89, + 504, + 111 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 89, + 505, + 102 + ], + "spans": [ + { + "bbox": [ + 105, + 89, + 505, + 102 + ], + "score": 1.0, + "content": "Figure 4: Stability comparisons of ES and PG on the Biased-Sensor CartPole and Swimmer,", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 100, + 483, + 112 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 483, + 112 + ], + "score": 1.0, + "content": "Walker2d environments. (L), (H), and (HH) denote linear, one- and two-hidden layer policies.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "image_body", + "bbox": [ + 110, + 113, + 500, + 208 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 113, + 500, + 208 + ], + "spans": [ + { + "bbox": [ + 110, + 113, + 500, + 208 + ], + "score": 0.955, + "type": "image", + "image_path": "dd5d2488f52f41293baaa80eb977559d5924da6ae5098cb338b0c7f7cb5920e5.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 110, + 113, + 500, + 144.66666666666666 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 110, + 144.66666666666666, + 500, + 176.33333333333331 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 110, + 176.33333333333331, + 500, + 207.99999999999997 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 1.75 + }, + { + "type": "text", + "bbox": [ + 107, + 228, + 505, + 261 + ], + "lines": [ + { + "bbox": [ + 106, + 227, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 505, + 241 + ], + "score": 1.0, + "content": "We also include results in Figure 4 from two other environments, Swimmer and Walker2d, for which", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 239, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 505, + 252 + ], + "score": 1.0, + "content": "it is known that PG is surprisingly unstable, and ES yields better training (Mania et al., 2018). Notice", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 249, + 505, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 249, + 505, + 263 + ], + "score": 1.0, + "content": "that we again find linear policies (L) outperforming policies with one (H) or two (HH) hidden layers.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "title", + "bbox": [ + 108, + 275, + 229, + 285 + ], + "lines": [ + { + "bbox": [ + 106, + 273, + 230, + 287 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 154, + 287 + ], + "score": 1.0, + "content": "4.4 LOW-", + "type": "text" + }, + { + "bbox": [ + 155, + 275, + 165, + 285 + ], + "score": 0.61, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 273, + 230, + 287 + ], + "score": 1.0, + "content": "BENCHMARKS", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 295, + 505, + 328 + ], + "lines": [ + { + "bbox": [ + 105, + 295, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 398, + 308 + ], + "score": 1.0, + "content": "For real-world applications, we may be constrained to use fewer queries", + "type": "text" + }, + { + "bbox": [ + 398, + 296, + 409, + 305 + ], + "score": 0.81, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 295, + 505, + 308 + ], + "score": 1.0, + "content": "than has typically been", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 307, + 505, + 318 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 505, + 318 + ], + "score": 1.0, + "content": "demonstrated in previous MAML works. Hence, it is of interest to compare how ES-MAML com-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 318, + 313, + 329 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 298, + 329 + ], + "score": 1.0, + "content": "pares to PG-MAML for adapting with very low", + "type": "text" + }, + { + "bbox": [ + 298, + 318, + 308, + 327 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 318, + 313, + 329 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 334, + 505, + 378 + ], + "lines": [ + { + "bbox": [ + 106, + 334, + 505, + 346 + ], + "spans": [ + { + "bbox": [ + 106, + 334, + 238, + 346 + ], + "score": 1.0, + "content": "One possible concern is that low", + "type": "text" + }, + { + "bbox": [ + 238, + 335, + 248, + 344 + ], + "score": 0.79, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 334, + 505, + 346 + ], + "score": 1.0, + "content": "might harm ES in particular because it uses only the cumulative", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 345, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 203, + 357 + ], + "score": 1.0, + "content": "rewards; if for example", + "type": "text" + }, + { + "bbox": [ + 203, + 345, + 233, + 355 + ], + "score": 0.9, + "content": "K = 5", + "type": "inline_equation" + }, + { + "bbox": [ + 233, + 345, + 505, + 357 + ], + "score": 1.0, + "content": ", then the ES adaptation gradient can make use of only 5 values. In", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 356, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 228, + 369 + ], + "score": 1.0, + "content": "comparison, PG-MAML uses", + "type": "text" + }, + { + "bbox": [ + 229, + 356, + 257, + 366 + ], + "score": 0.89, + "content": "K \\cdot H", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 356, + 359, + 369 + ], + "score": 1.0, + "content": "state-action pairs, so for", + "type": "text" + }, + { + "bbox": [ + 359, + 356, + 433, + 367 + ], + "score": 0.91, + "content": "K = 5 , H = 2 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 356, + 505, + 369 + ], + "score": 1.0, + "content": ", PG-MAML still", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 367, + 273, + 379 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 273, + 379 + ], + "score": 1.0, + "content": "has 1000 pieces of information available.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 106, + 384, + 505, + 472 + ], + "lines": [ + { + "bbox": [ + 106, + 384, + 505, + 396 + ], + "spans": [ + { + "bbox": [ + 106, + 384, + 505, + 396 + ], + "score": 1.0, + "content": "However, we find experimentally that the standard ES-MAML (Algorithm 3) remains competitive", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 395, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 106, + 395, + 238, + 407 + ], + "score": 1.0, + "content": "with PG-MAML even in the low-", + "type": "text" + }, + { + "bbox": [ + 238, + 396, + 248, + 405 + ], + "score": 0.8, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 395, + 505, + 407 + ], + "score": 1.0, + "content": "setting. In Figure 5, we compare ES-MAML and PG-MAML on", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 405, + 506, + 419 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 506, + 419 + ], + "score": 1.0, + "content": "the Forward-Backward and Goal-Velocity tasks across four environments (HalfCheetah, Swimmer,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 416, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 106, + 416, + 505, + 429 + ], + "score": 1.0, + "content": "Walker2d, Ant) and two model architectures. While PG-MAML can generally outperform ES-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 427, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 505, + 439 + ], + "score": 1.0, + "content": "MAML on the Goal-Velocity task, ES-MAML is similar or better on the Forward-Backward task.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 439, + 506, + 451 + ], + "spans": [ + { + "bbox": [ + 106, + 439, + 258, + 451 + ], + "score": 1.0, + "content": "Moreover, we observed that for low", + "type": "text" + }, + { + "bbox": [ + 258, + 439, + 268, + 449 + ], + "score": 0.67, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 439, + 506, + 451 + ], + "score": 1.0, + "content": ", PG-MAML can be highly unstable (note the wide error", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 450, + 505, + 462 + ], + "spans": [ + { + "bbox": [ + 106, + 450, + 505, + 462 + ], + "score": 1.0, + "content": "bars), with some trajectories failing catastrophically, whereas ES-MAML is relatively stable. This is", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 461, + 505, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 505, + 473 + ], + "score": 1.0, + "content": "an important consideration in real applications, where the risk of catastrophic failure is undesirable.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 19.5 + }, + { + "type": "image", + "bbox": [ + 107, + 503, + 504, + 718 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 165, + 491, + 441, + 503 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 164, + 490, + 444, + 505 + ], + "spans": [ + { + "bbox": [ + 164, + 490, + 226, + 505 + ], + "score": 1.0, + "content": "Figure 5: Low", + "type": "text" + }, + { + "bbox": [ + 226, + 492, + 236, + 501 + ], + "score": 0.66, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 236, + 490, + 444, + 505 + ], + "score": 1.0, + "content": "comparisons between ES-MAML and PG-MAML.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "image_body", + "bbox": [ + 107, + 503, + 504, + 718 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 107, + 503, + 504, + 718 + ], + "spans": [ + { + "bbox": [ + 107, + 503, + 504, + 718 + ], + "score": 0.973, + "type": "image", + "image_path": "4e4c088e05427dc9efc62b542510eeeade9c204551dbf77412efe8e315f1aba0.jpg" + } + ] + } + ], + "index": 26, + "virtual_lines": [ + { + "bbox": [ + 107, + 503, + 504, + 574.6666666666666 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 107, + 574.6666666666666, + 504, + 646.3333333333333 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 107, + 646.3333333333333, + 504, + 717.9999999999999 + ], + "spans": [], + "index": 27 + } + ] + } + ], + "index": 25.0 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 300, + 750, + 309, + 761 + ], + "spans": [ + { + "bbox": [ + 300, + 750, + 309, + 761 + ], + "score": 1.0, + "content": "8", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 110, + 113, + 500, + 208 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 106, + 89, + 504, + 111 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 89, + 505, + 102 + ], + "spans": [ + { + "bbox": [ + 105, + 89, + 505, + 102 + ], + "score": 1.0, + "content": "Figure 4: Stability comparisons of ES and PG on the Biased-Sensor CartPole and Swimmer,", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 100, + 483, + 112 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 483, + 112 + ], + "score": 1.0, + "content": "Walker2d environments. (L), (H), and (HH) denote linear, one- and two-hidden layer policies.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "image_body", + "bbox": [ + 110, + 113, + 500, + 208 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 113, + 500, + 208 + ], + "spans": [ + { + "bbox": [ + 110, + 113, + 500, + 208 + ], + "score": 0.955, + "type": "image", + "image_path": "dd5d2488f52f41293baaa80eb977559d5924da6ae5098cb338b0c7f7cb5920e5.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 110, + 113, + 500, + 144.66666666666666 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 110, + 144.66666666666666, + 500, + 176.33333333333331 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 110, + 176.33333333333331, + 500, + 207.99999999999997 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 1.75 + }, + { + "type": "text", + "bbox": [ + 107, + 228, + 505, + 261 + ], + "lines": [ + { + "bbox": [ + 106, + 227, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 505, + 241 + ], + "score": 1.0, + "content": "We also include results in Figure 4 from two other environments, Swimmer and Walker2d, for which", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 239, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 505, + 252 + ], + "score": 1.0, + "content": "it is known that PG is surprisingly unstable, and ES yields better training (Mania et al., 2018). Notice", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 249, + 505, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 249, + 505, + 263 + ], + "score": 1.0, + "content": "that we again find linear policies (L) outperforming policies with one (H) or two (HH) hidden layers.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6, + "bbox_fs": [ + 105, + 227, + 505, + 263 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 275, + 229, + 285 + ], + "lines": [ + { + "bbox": [ + 106, + 273, + 230, + 287 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 154, + 287 + ], + "score": 1.0, + "content": "4.4 LOW-", + "type": "text" + }, + { + "bbox": [ + 155, + 275, + 165, + 285 + ], + "score": 0.61, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 273, + 230, + 287 + ], + "score": 1.0, + "content": "BENCHMARKS", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 295, + 505, + 328 + ], + "lines": [ + { + "bbox": [ + 105, + 295, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 398, + 308 + ], + "score": 1.0, + "content": "For real-world applications, we may be constrained to use fewer queries", + "type": "text" + }, + { + "bbox": [ + 398, + 296, + 409, + 305 + ], + "score": 0.81, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 295, + 505, + 308 + ], + "score": 1.0, + "content": "than has typically been", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 307, + 505, + 318 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 505, + 318 + ], + "score": 1.0, + "content": "demonstrated in previous MAML works. Hence, it is of interest to compare how ES-MAML com-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 318, + 313, + 329 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 298, + 329 + ], + "score": 1.0, + "content": "pares to PG-MAML for adapting with very low", + "type": "text" + }, + { + "bbox": [ + 298, + 318, + 308, + 327 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 318, + 313, + 329 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10, + "bbox_fs": [ + 105, + 295, + 505, + 329 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 334, + 505, + 378 + ], + "lines": [ + { + "bbox": [ + 106, + 334, + 505, + 346 + ], + "spans": [ + { + "bbox": [ + 106, + 334, + 238, + 346 + ], + "score": 1.0, + "content": "One possible concern is that low", + "type": "text" + }, + { + "bbox": [ + 238, + 335, + 248, + 344 + ], + "score": 0.79, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 334, + 505, + 346 + ], + "score": 1.0, + "content": "might harm ES in particular because it uses only the cumulative", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 345, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 203, + 357 + ], + "score": 1.0, + "content": "rewards; if for example", + "type": "text" + }, + { + "bbox": [ + 203, + 345, + 233, + 355 + ], + "score": 0.9, + "content": "K = 5", + "type": "inline_equation" + }, + { + "bbox": [ + 233, + 345, + 505, + 357 + ], + "score": 1.0, + "content": ", then the ES adaptation gradient can make use of only 5 values. In", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 356, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 228, + 369 + ], + "score": 1.0, + "content": "comparison, PG-MAML uses", + "type": "text" + }, + { + "bbox": [ + 229, + 356, + 257, + 366 + ], + "score": 0.89, + "content": "K \\cdot H", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 356, + 359, + 369 + ], + "score": 1.0, + "content": "state-action pairs, so for", + "type": "text" + }, + { + "bbox": [ + 359, + 356, + 433, + 367 + ], + "score": 0.91, + "content": "K = 5 , H = 2 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 356, + 505, + 369 + ], + "score": 1.0, + "content": ", PG-MAML still", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 367, + 273, + 379 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 273, + 379 + ], + "score": 1.0, + "content": "has 1000 pieces of information available.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13.5, + "bbox_fs": [ + 105, + 334, + 505, + 379 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 384, + 505, + 472 + ], + "lines": [ + { + "bbox": [ + 106, + 384, + 505, + 396 + ], + "spans": [ + { + "bbox": [ + 106, + 384, + 505, + 396 + ], + "score": 1.0, + "content": "However, we find experimentally that the standard ES-MAML (Algorithm 3) remains competitive", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 395, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 106, + 395, + 238, + 407 + ], + "score": 1.0, + "content": "with PG-MAML even in the low-", + "type": "text" + }, + { + "bbox": [ + 238, + 396, + 248, + 405 + ], + "score": 0.8, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 395, + 505, + 407 + ], + "score": 1.0, + "content": "setting. In Figure 5, we compare ES-MAML and PG-MAML on", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 405, + 506, + 419 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 506, + 419 + ], + "score": 1.0, + "content": "the Forward-Backward and Goal-Velocity tasks across four environments (HalfCheetah, Swimmer,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 416, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 106, + 416, + 505, + 429 + ], + "score": 1.0, + "content": "Walker2d, Ant) and two model architectures. While PG-MAML can generally outperform ES-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 427, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 505, + 439 + ], + "score": 1.0, + "content": "MAML on the Goal-Velocity task, ES-MAML is similar or better on the Forward-Backward task.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 439, + 506, + 451 + ], + "spans": [ + { + "bbox": [ + 106, + 439, + 258, + 451 + ], + "score": 1.0, + "content": "Moreover, we observed that for low", + "type": "text" + }, + { + "bbox": [ + 258, + 439, + 268, + 449 + ], + "score": 0.67, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 439, + 506, + 451 + ], + "score": 1.0, + "content": ", PG-MAML can be highly unstable (note the wide error", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 450, + 505, + 462 + ], + "spans": [ + { + "bbox": [ + 106, + 450, + 505, + 462 + ], + "score": 1.0, + "content": "bars), with some trajectories failing catastrophically, whereas ES-MAML is relatively stable. This is", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 461, + 505, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 505, + 473 + ], + "score": 1.0, + "content": "an important consideration in real applications, where the risk of catastrophic failure is undesirable.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 384, + 506, + 473 + ] + }, + { + "type": "image", + "bbox": [ + 107, + 503, + 504, + 718 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 165, + 491, + 441, + 503 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 164, + 490, + 444, + 505 + ], + "spans": [ + { + "bbox": [ + 164, + 490, + 226, + 505 + ], + "score": 1.0, + "content": "Figure 5: Low", + "type": "text" + }, + { + "bbox": [ + 226, + 492, + 236, + 501 + ], + "score": 0.66, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 236, + 490, + 444, + 505 + ], + "score": 1.0, + "content": "comparisons between ES-MAML and PG-MAML.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "image_body", + "bbox": [ + 107, + 503, + 504, + 718 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 107, + 503, + 504, + 718 + ], + "spans": [ + { + "bbox": [ + 107, + 503, + 504, + 718 + ], + "score": 0.973, + "type": "image", + "image_path": "4e4c088e05427dc9efc62b542510eeeade9c204551dbf77412efe8e315f1aba0.jpg" + } + ] + } + ], + "index": 26, + "virtual_lines": [ + { + "bbox": [ + 107, + 503, + 504, + 574.6666666666666 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 107, + 574.6666666666666, + 504, + 646.3333333333333 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 107, + 646.3333333333333, + 504, + 717.9999999999999 + ], + "spans": [], + "index": 27 + } + ] + } + ], + "index": 25.0 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 195, + 93 + ], + "lines": [ + { + "bbox": [ + 104, + 79, + 197, + 97 + ], + "spans": [ + { + "bbox": [ + 104, + 79, + 197, + 97 + ], + "score": 1.0, + "content": "5 CONCLUSION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 106, + 505, + 195 + ], + "lines": [ + { + "bbox": [ + 106, + 106, + 505, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 106, + 505, + 118 + ], + "score": 1.0, + "content": "We have presented a new framework for MAML based on ES algorithms. The ES-MAML approach", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 117, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 505, + 128 + ], + "score": 1.0, + "content": "avoids the problems of Hessian estimation which necessitated complicated alterations in PG-MAML", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 128, + 505, + 141 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 505, + 141 + ], + "score": 1.0, + "content": "and is straightforward to implement. ES-MAML is flexible in the choice of adaptation operators,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 139, + 505, + 152 + ], + "spans": [ + { + "bbox": [ + 105, + 139, + 505, + 152 + ], + "score": 1.0, + "content": "and can be augmented with general improvements to ES, along with more exotic adaptation op-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 150, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 105, + 150, + 505, + 163 + ], + "score": 1.0, + "content": "erators. In particular, ES-MAML can be paired with nonsmooth adaptation operators such as hill", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 160, + 505, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 160, + 505, + 174 + ], + "score": 1.0, + "content": "climbing, which we found empirically to yield better exploratory behavior and better performance", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 172, + 506, + 185 + ], + "spans": [ + { + "bbox": [ + 105, + 172, + 506, + 185 + ], + "score": 1.0, + "content": "on sparse-reward environments. ES-MAML performs well with linear or compact deterministic", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 183, + 467, + 196 + ], + "spans": [ + { + "bbox": [ + 105, + 183, + 467, + 196 + ], + "score": 1.0, + "content": "policies, which is an advantage when adapting if the state dynamics are possibly unstable.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 4.5 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 195, + 93 + ], + "lines": [ + { + "bbox": [ + 104, + 79, + 197, + 97 + ], + "spans": [ + { + "bbox": [ + 104, + 79, + 197, + 97 + ], + "score": 1.0, + "content": "5 CONCLUSION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 106, + 505, + 195 + ], + "lines": [ + { + "bbox": [ + 106, + 106, + 505, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 106, + 505, + 118 + ], + "score": 1.0, + "content": "We have presented a new framework for MAML based on ES algorithms. The ES-MAML approach", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 117, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 505, + 128 + ], + "score": 1.0, + "content": "avoids the problems of Hessian estimation which necessitated complicated alterations in PG-MAML", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 128, + 505, + 141 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 505, + 141 + ], + "score": 1.0, + "content": "and is straightforward to implement. ES-MAML is flexible in the choice of adaptation operators,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 139, + 505, + 152 + ], + "spans": [ + { + "bbox": [ + 105, + 139, + 505, + 152 + ], + "score": 1.0, + "content": "and can be augmented with general improvements to ES, along with more exotic adaptation op-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 150, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 105, + 150, + 505, + 163 + ], + "score": 1.0, + "content": "erators. In particular, ES-MAML can be paired with nonsmooth adaptation operators such as hill", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 160, + 505, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 160, + 505, + 174 + ], + "score": 1.0, + "content": "climbing, which we found empirically to yield better exploratory behavior and better performance", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 172, + 506, + 185 + ], + "spans": [ + { + "bbox": [ + 105, + 172, + 506, + 185 + ], + "score": 1.0, + "content": "on sparse-reward environments. ES-MAML performs well with linear or compact deterministic", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 183, + 467, + 196 + ], + "spans": [ + { + "bbox": [ + 105, + 183, + 467, + 196 + ], + "score": 1.0, + "content": "policies, which is an advantage when adapting if the state dynamics are possibly unstable.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 4.5, + "bbox_fs": [ + 105, + 106, + 506, + 196 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 176, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 176, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 176, + 94 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 108, + 100, + 503, + 135 + ], + "lines": [ + { + "bbox": [ + 105, + 100, + 505, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 100, + 505, + 113 + ], + "score": 1.0, + "content": "Maruan Al-Shedivat, Trapit Bansal, Yura Burda, Ilya Sutskever, Igor Mordatch, and Pieter Abbeel.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 117, + 113, + 504, + 124 + ], + "spans": [ + { + "bbox": [ + 117, + 113, + 504, + 124 + ], + "score": 1.0, + "content": "Continuous adaptation via meta-learning in nonstationary and competitive environments. In In-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 116, + 123, + 357, + 135 + ], + "spans": [ + { + "bbox": [ + 116, + 123, + 357, + 135 + ], + "score": 1.0, + "content": "ternational Conference on Learning Representations, 2018.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 106, + 142, + 505, + 177 + ], + "lines": [ + { + "bbox": [ + 105, + 142, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 505, + 156 + ], + "score": 1.0, + "content": "Antreas Antoniou, Harrison Edwards, and Amos J. Storkey. How to train your MAML. In 7th", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 153, + 506, + 168 + ], + "spans": [ + { + "bbox": [ + 115, + 153, + 506, + 168 + ], + "score": 1.0, + "content": "International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 116, + 165, + 185, + 177 + ], + "spans": [ + { + "bbox": [ + 116, + 165, + 185, + 177 + ], + "score": 1.0, + "content": "6-9, 2019, 2019.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 107, + 185, + 502, + 208 + ], + "lines": [ + { + "bbox": [ + 106, + 186, + 504, + 199 + ], + "spans": [ + { + "bbox": [ + 106, + 186, + 504, + 199 + ], + "score": 1.0, + "content": "Harkirat Singh Behl, Atilim Gunes Baydin, and Philip H. S. Torr. Alpha MAML: adaptive model-¨", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 116, + 197, + 336, + 208 + ], + "spans": [ + { + "bbox": [ + 116, + 197, + 336, + 208 + ], + "score": 1.0, + "content": "agnostic meta-learning. CoRR, abs/1905.07435, 2019.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 105, + 217, + 504, + 240 + ], + "lines": [ + { + "bbox": [ + 106, + 217, + 505, + 230 + ], + "spans": [ + { + "bbox": [ + 106, + 217, + 505, + 230 + ], + "score": 1.0, + "content": "Jose Blanchet, Donald Goldfarb, Garud Iyengar, Fengpei Li, and Chaoxu Zhou. Unbiased simulation", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 228, + 416, + 241 + ], + "spans": [ + { + "bbox": [ + 115, + 228, + 416, + 241 + ], + "score": 1.0, + "content": "for optimizing stochastic function compositions. arXiv:1711.07564, 2017.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 107, + 248, + 505, + 294 + ], + "lines": [ + { + "bbox": [ + 106, + 249, + 504, + 261 + ], + "spans": [ + { + "bbox": [ + 106, + 249, + 504, + 261 + ], + "score": 1.0, + "content": "Krzysztof Choromanski, Mark Rowland, Vikas Sindhwani, Richard E. Turner, and Adrian Weller.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 115, + 259, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 115, + 259, + 505, + 273 + ], + "score": 1.0, + "content": "Structured evolution with compact architectures for scalable policy optimization. In Proceed-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 272, + 504, + 284 + ], + "spans": [ + { + "bbox": [ + 116, + 272, + 504, + 284 + ], + "score": 1.0, + "content": "ings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan,¨", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 282, + 349, + 294 + ], + "spans": [ + { + "bbox": [ + 116, + 282, + 349, + 294 + ], + "score": 1.0, + "content": "Stockholm, Sweden, July 10-15, 2018, pp. 969–977, 2018.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 107, + 302, + 505, + 336 + ], + "lines": [ + { + "bbox": [ + 105, + 302, + 504, + 315 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 504, + 315 + ], + "score": 1.0, + "content": "Krzysztof Choromanski, Aldo Pacchiano, Jack Parker-Holder, and Yunhao Tang. Struc-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 313, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 116, + 313, + 505, + 327 + ], + "score": 1.0, + "content": "tured monte carlo sampling for nonisotropic distributions via determinantal point processes.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 116, + 325, + 223, + 336 + ], + "spans": [ + { + "bbox": [ + 116, + 325, + 223, + 336 + ], + "score": 1.0, + "content": "arXiv:1905.12667, 2019a.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 345, + 503, + 368 + ], + "lines": [ + { + "bbox": [ + 105, + 344, + 505, + 359 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 505, + 359 + ], + "score": 1.0, + "content": "Krzysztof Choromanski, Aldo Pacchiano, Jack Parker-Holder, and Yunhao Tang. From complexity", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 115, + 357, + 491, + 369 + ], + "spans": [ + { + "bbox": [ + 115, + 357, + 491, + 369 + ], + "score": 1.0, + "content": "to simplicity: Adaptive es-active subspaces for blackbox optimization. NeurIPS 2019, 2019b.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18.5 + }, + { + "type": "text", + "bbox": [ + 107, + 377, + 503, + 411 + ], + "lines": [ + { + "bbox": [ + 105, + 375, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 505, + 392 + ], + "score": 1.0, + "content": "Krzysztof Choromanski, Aldo Pacchiano, Jack Parker-Holder, Yunhao Tang, Deepali Jain, Yuxiang", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 117, + 388, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 117, + 388, + 505, + 400 + ], + "score": 1.0, + "content": "Yang, Atil Iscen, Jasmine Hsu, and Vikas Sindhwani. Provably robust blackbox optimization for", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 399, + 342, + 411 + ], + "spans": [ + { + "bbox": [ + 115, + 399, + 342, + 411 + ], + "score": 1.0, + "content": "reinforcement learning. accepted to CoRL 2019, 2019c.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 106, + 419, + 505, + 475 + ], + "lines": [ + { + "bbox": [ + 106, + 420, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 505, + 432 + ], + "score": 1.0, + "content": "Chrisantha Fernando, Jakub Sygnowski, Simon Osindero, Jane Wang, Tom Schaul, Denis", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 429, + 505, + 444 + ], + "spans": [ + { + "bbox": [ + 115, + 429, + 505, + 444 + ], + "score": 1.0, + "content": "Teplyashin, Pablo Sprechmann, Alexander Pritzel, and Andrei A. Rusu. Meta-learning by", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 441, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 115, + 441, + 505, + 455 + ], + "score": 1.0, + "content": "the baldwin effect. In Proceedings of the Genetic and Evolutionary Computation Confer-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 116, + 452, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 116, + 452, + 505, + 465 + ], + "score": 1.0, + "content": "ence Companion, GECCO 2018, Kyoto, Japan, July 15-19, 2018, pp. 109–110, 2018. doi:", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 462, + 491, + 476 + ], + "spans": [ + { + "bbox": [ + 115, + 462, + 491, + 476 + ], + "score": 1.0, + "content": "10.1145/3205651.3205763. URL https://doi.org/10.1145/3205651.3205763.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 483, + 505, + 529 + ], + "lines": [ + { + "bbox": [ + 106, + 484, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 505, + 497 + ], + "score": 1.0, + "content": "Chelsea Finn and Sergey Levine. Meta-learning and universality: Deep representations and gradient", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 495, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 115, + 495, + 505, + 509 + ], + "score": 1.0, + "content": "descent can approximate any learning algorithm. In 6th International Conference on Learning", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 506, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 115, + 506, + 505, + 518 + ], + "score": 1.0, + "content": "Representations, ICLR 2018, Vancouver, BC, Canada, April 30 - May 3, 2018, Conference Track", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 116, + 518, + 196, + 530 + ], + "spans": [ + { + "bbox": [ + 116, + 518, + 196, + 530 + ], + "score": 1.0, + "content": "Proceedings, 2018.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 106, + 537, + 503, + 572 + ], + "lines": [ + { + "bbox": [ + 106, + 538, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 505, + 550 + ], + "score": 1.0, + "content": "Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 547, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 115, + 547, + 505, + 563 + ], + "score": 1.0, + "content": "of deep networks. In Proceedings of the 34th International Conference on Machine Learning,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 116, + 560, + 430, + 572 + ], + "spans": [ + { + "bbox": [ + 116, + 560, + 430, + 572 + ], + "score": 1.0, + "content": "ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 1126–1135, 2017.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 106, + 579, + 505, + 625 + ], + "lines": [ + { + "bbox": [ + 106, + 581, + 505, + 592 + ], + "spans": [ + { + "bbox": [ + 106, + 581, + 505, + 592 + ], + "score": 1.0, + "content": "Chelsea Finn, Kelvin Xu, and Sergey Levine. Probabilistic model-agnostic meta-learning. In Ad-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 592, + 505, + 604 + ], + "spans": [ + { + "bbox": [ + 116, + 592, + 505, + 604 + ], + "score": 1.0, + "content": "vances in Neural Information Processing Systems 31: Annual Conference on Neural Information", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 602, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 115, + 602, + 506, + 614 + ], + "score": 1.0, + "content": "Processing Systems 2018, NeurIPS 2018, 3-8 December 2018, Montreal, Canada. ´ , pp. 9537–", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 613, + 165, + 624 + ], + "spans": [ + { + "bbox": [ + 115, + 613, + 165, + 624 + ], + "score": 1.0, + "content": "9548, 2018.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 106, + 633, + 505, + 668 + ], + "lines": [ + { + "bbox": [ + 105, + 633, + 505, + 647 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 505, + 647 + ], + "score": 1.0, + "content": "Jakob Foerster, Gregory Farquhar, Maruan Al-Shedivat, Tim Rocktaschel, Eric Xing, and Shimon ¨", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 117, + 645, + 505, + 658 + ], + "spans": [ + { + "bbox": [ + 117, + 645, + 505, + 658 + ], + "score": 1.0, + "content": "Whiteson. DiCE: The infinitely differentiable Monte Carlo estimator. In Proceedings of the 35th", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 115, + 656, + 448, + 668 + ], + "spans": [ + { + "bbox": [ + 115, + 656, + 448, + 668 + ], + "score": 1.0, + "content": "International Conference on Machine Learning, volume 80, pp. 1529–1538, 2018.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 676, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 676, + 505, + 690 + ], + "score": 1.0, + "content": "Alexander Gajewski, Jeff Clune, Kenneth O. Stanley, and Joel Lehman. Evolvability ES: scalable", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 116, + 688, + 504, + 700 + ], + "spans": [ + { + "bbox": [ + 116, + 688, + 504, + 700 + ], + "score": 1.0, + "content": "and direct optimization of evolvability. In Proceedings of the Genetic and Evolutionary Com-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 115, + 699, + 505, + 712 + ], + "score": 1.0, + "content": "putation Conference, GECCO 2019, Prague, Czech Republic, July 13-17, 2019, pp. 107–115,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 708, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 115, + 708, + 504, + 722 + ], + "score": 1.0, + "content": "2019. doi: 10.1145/3321707.3321876. URL https://doi.org/10.1145/3321707.", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 115, + 720, + 164, + 733 + ], + "spans": [ + { + "bbox": [ + 115, + 720, + 164, + 733 + ], + "score": 1.0, + "content": "3321876.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 44 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "10", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 176, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 176, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 176, + 94 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 108, + 100, + 503, + 135 + ], + "lines": [ + { + "bbox": [ + 105, + 100, + 505, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 100, + 505, + 113 + ], + "score": 1.0, + "content": "Maruan Al-Shedivat, Trapit Bansal, Yura Burda, Ilya Sutskever, Igor Mordatch, and Pieter Abbeel.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 117, + 113, + 504, + 124 + ], + "spans": [ + { + "bbox": [ + 117, + 113, + 504, + 124 + ], + "score": 1.0, + "content": "Continuous adaptation via meta-learning in nonstationary and competitive environments. In In-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 116, + 123, + 357, + 135 + ], + "spans": [ + { + "bbox": [ + 116, + 123, + 357, + 135 + ], + "score": 1.0, + "content": "ternational Conference on Learning Representations, 2018.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2, + "bbox_fs": [ + 105, + 100, + 505, + 135 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 142, + 505, + 177 + ], + "lines": [ + { + "bbox": [ + 105, + 142, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 505, + 156 + ], + "score": 1.0, + "content": "Antreas Antoniou, Harrison Edwards, and Amos J. Storkey. How to train your MAML. In 7th", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 153, + 506, + 168 + ], + "spans": [ + { + "bbox": [ + 115, + 153, + 506, + 168 + ], + "score": 1.0, + "content": "International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 116, + 165, + 185, + 177 + ], + "spans": [ + { + "bbox": [ + 116, + 165, + 185, + 177 + ], + "score": 1.0, + "content": "6-9, 2019, 2019.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5, + "bbox_fs": [ + 105, + 142, + 506, + 177 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 185, + 502, + 208 + ], + "lines": [ + { + "bbox": [ + 106, + 186, + 504, + 199 + ], + "spans": [ + { + "bbox": [ + 106, + 186, + 504, + 199 + ], + "score": 1.0, + "content": "Harkirat Singh Behl, Atilim Gunes Baydin, and Philip H. S. Torr. Alpha MAML: adaptive model-¨", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 116, + 197, + 336, + 208 + ], + "spans": [ + { + "bbox": [ + 116, + 197, + 336, + 208 + ], + "score": 1.0, + "content": "agnostic meta-learning. CoRR, abs/1905.07435, 2019.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5, + "bbox_fs": [ + 106, + 186, + 504, + 208 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 217, + 504, + 240 + ], + "lines": [ + { + "bbox": [ + 106, + 217, + 505, + 230 + ], + "spans": [ + { + "bbox": [ + 106, + 217, + 505, + 230 + ], + "score": 1.0, + "content": "Jose Blanchet, Donald Goldfarb, Garud Iyengar, Fengpei Li, and Chaoxu Zhou. Unbiased simulation", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 228, + 416, + 241 + ], + "spans": [ + { + "bbox": [ + 115, + 228, + 416, + 241 + ], + "score": 1.0, + "content": "for optimizing stochastic function compositions. arXiv:1711.07564, 2017.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5, + "bbox_fs": [ + 106, + 217, + 505, + 241 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 248, + 505, + 294 + ], + "lines": [ + { + "bbox": [ + 106, + 249, + 504, + 261 + ], + "spans": [ + { + "bbox": [ + 106, + 249, + 504, + 261 + ], + "score": 1.0, + "content": "Krzysztof Choromanski, Mark Rowland, Vikas Sindhwani, Richard E. Turner, and Adrian Weller.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 115, + 259, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 115, + 259, + 505, + 273 + ], + "score": 1.0, + "content": "Structured evolution with compact architectures for scalable policy optimization. In Proceed-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 272, + 504, + 284 + ], + "spans": [ + { + "bbox": [ + 116, + 272, + 504, + 284 + ], + "score": 1.0, + "content": "ings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan,¨", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 282, + 349, + 294 + ], + "spans": [ + { + "bbox": [ + 116, + 282, + 349, + 294 + ], + "score": 1.0, + "content": "Stockholm, Sweden, July 10-15, 2018, pp. 969–977, 2018.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12.5, + "bbox_fs": [ + 106, + 249, + 505, + 294 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 302, + 505, + 336 + ], + "lines": [ + { + "bbox": [ + 105, + 302, + 504, + 315 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 504, + 315 + ], + "score": 1.0, + "content": "Krzysztof Choromanski, Aldo Pacchiano, Jack Parker-Holder, and Yunhao Tang. Struc-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 313, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 116, + 313, + 505, + 327 + ], + "score": 1.0, + "content": "tured monte carlo sampling for nonisotropic distributions via determinantal point processes.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 116, + 325, + 223, + 336 + ], + "spans": [ + { + "bbox": [ + 116, + 325, + 223, + 336 + ], + "score": 1.0, + "content": "arXiv:1905.12667, 2019a.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16, + "bbox_fs": [ + 105, + 302, + 505, + 336 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 345, + 503, + 368 + ], + "lines": [ + { + "bbox": [ + 105, + 344, + 505, + 359 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 505, + 359 + ], + "score": 1.0, + "content": "Krzysztof Choromanski, Aldo Pacchiano, Jack Parker-Holder, and Yunhao Tang. From complexity", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 115, + 357, + 491, + 369 + ], + "spans": [ + { + "bbox": [ + 115, + 357, + 491, + 369 + ], + "score": 1.0, + "content": "to simplicity: Adaptive es-active subspaces for blackbox optimization. NeurIPS 2019, 2019b.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18.5, + "bbox_fs": [ + 105, + 344, + 505, + 369 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 377, + 503, + 411 + ], + "lines": [ + { + "bbox": [ + 105, + 375, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 505, + 392 + ], + "score": 1.0, + "content": "Krzysztof Choromanski, Aldo Pacchiano, Jack Parker-Holder, Yunhao Tang, Deepali Jain, Yuxiang", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 117, + 388, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 117, + 388, + 505, + 400 + ], + "score": 1.0, + "content": "Yang, Atil Iscen, Jasmine Hsu, and Vikas Sindhwani. Provably robust blackbox optimization for", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 399, + 342, + 411 + ], + "spans": [ + { + "bbox": [ + 115, + 399, + 342, + 411 + ], + "score": 1.0, + "content": "reinforcement learning. accepted to CoRL 2019, 2019c.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 375, + 505, + 411 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 419, + 505, + 475 + ], + "lines": [ + { + "bbox": [ + 106, + 420, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 505, + 432 + ], + "score": 1.0, + "content": "Chrisantha Fernando, Jakub Sygnowski, Simon Osindero, Jane Wang, Tom Schaul, Denis", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 429, + 505, + 444 + ], + "spans": [ + { + "bbox": [ + 115, + 429, + 505, + 444 + ], + "score": 1.0, + "content": "Teplyashin, Pablo Sprechmann, Alexander Pritzel, and Andrei A. Rusu. Meta-learning by", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 441, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 115, + 441, + 505, + 455 + ], + "score": 1.0, + "content": "the baldwin effect. In Proceedings of the Genetic and Evolutionary Computation Confer-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 116, + 452, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 116, + 452, + 505, + 465 + ], + "score": 1.0, + "content": "ence Companion, GECCO 2018, Kyoto, Japan, July 15-19, 2018, pp. 109–110, 2018. doi:", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 462, + 491, + 476 + ], + "spans": [ + { + "bbox": [ + 115, + 462, + 491, + 476 + ], + "score": 1.0, + "content": "10.1145/3205651.3205763. URL https://doi.org/10.1145/3205651.3205763.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25, + "bbox_fs": [ + 106, + 420, + 505, + 476 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 483, + 505, + 529 + ], + "lines": [ + { + "bbox": [ + 106, + 484, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 505, + 497 + ], + "score": 1.0, + "content": "Chelsea Finn and Sergey Levine. Meta-learning and universality: Deep representations and gradient", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 495, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 115, + 495, + 505, + 509 + ], + "score": 1.0, + "content": "descent can approximate any learning algorithm. In 6th International Conference on Learning", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 506, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 115, + 506, + 505, + 518 + ], + "score": 1.0, + "content": "Representations, ICLR 2018, Vancouver, BC, Canada, April 30 - May 3, 2018, Conference Track", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 116, + 518, + 196, + 530 + ], + "spans": [ + { + "bbox": [ + 116, + 518, + 196, + 530 + ], + "score": 1.0, + "content": "Proceedings, 2018.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5, + "bbox_fs": [ + 106, + 484, + 505, + 530 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 537, + 503, + 572 + ], + "lines": [ + { + "bbox": [ + 106, + 538, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 505, + 550 + ], + "score": 1.0, + "content": "Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 547, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 115, + 547, + 505, + 563 + ], + "score": 1.0, + "content": "of deep networks. In Proceedings of the 34th International Conference on Machine Learning,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 116, + 560, + 430, + 572 + ], + "spans": [ + { + "bbox": [ + 116, + 560, + 430, + 572 + ], + "score": 1.0, + "content": "ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 1126–1135, 2017.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33, + "bbox_fs": [ + 106, + 538, + 505, + 572 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 579, + 505, + 625 + ], + "lines": [ + { + "bbox": [ + 106, + 581, + 505, + 592 + ], + "spans": [ + { + "bbox": [ + 106, + 581, + 505, + 592 + ], + "score": 1.0, + "content": "Chelsea Finn, Kelvin Xu, and Sergey Levine. Probabilistic model-agnostic meta-learning. In Ad-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 592, + 505, + 604 + ], + "spans": [ + { + "bbox": [ + 116, + 592, + 505, + 604 + ], + "score": 1.0, + "content": "vances in Neural Information Processing Systems 31: Annual Conference on Neural Information", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 602, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 115, + 602, + 506, + 614 + ], + "score": 1.0, + "content": "Processing Systems 2018, NeurIPS 2018, 3-8 December 2018, Montreal, Canada. ´ , pp. 9537–", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 613, + 165, + 624 + ], + "spans": [ + { + "bbox": [ + 115, + 613, + 165, + 624 + ], + "score": 1.0, + "content": "9548, 2018.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5, + "bbox_fs": [ + 106, + 581, + 506, + 624 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 633, + 505, + 668 + ], + "lines": [ + { + "bbox": [ + 105, + 633, + 505, + 647 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 505, + 647 + ], + "score": 1.0, + "content": "Jakob Foerster, Gregory Farquhar, Maruan Al-Shedivat, Tim Rocktaschel, Eric Xing, and Shimon ¨", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 117, + 645, + 505, + 658 + ], + "spans": [ + { + "bbox": [ + 117, + 645, + 505, + 658 + ], + "score": 1.0, + "content": "Whiteson. DiCE: The infinitely differentiable Monte Carlo estimator. In Proceedings of the 35th", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 115, + 656, + 448, + 668 + ], + "spans": [ + { + "bbox": [ + 115, + 656, + 448, + 668 + ], + "score": 1.0, + "content": "International Conference on Machine Learning, volume 80, pp. 1529–1538, 2018.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40, + "bbox_fs": [ + 105, + 633, + 505, + 668 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 676, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 676, + 505, + 690 + ], + "score": 1.0, + "content": "Alexander Gajewski, Jeff Clune, Kenneth O. Stanley, and Joel Lehman. Evolvability ES: scalable", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 116, + 688, + 504, + 700 + ], + "spans": [ + { + "bbox": [ + 116, + 688, + 504, + 700 + ], + "score": 1.0, + "content": "and direct optimization of evolvability. In Proceedings of the Genetic and Evolutionary Com-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 115, + 699, + 505, + 712 + ], + "score": 1.0, + "content": "putation Conference, GECCO 2019, Prague, Czech Republic, July 13-17, 2019, pp. 107–115,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 708, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 115, + 708, + 504, + 722 + ], + "score": 1.0, + "content": "2019. doi: 10.1145/3321707.3321876. URL https://doi.org/10.1145/3321707.", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 115, + 720, + 164, + 733 + ], + "spans": [ + { + "bbox": [ + 115, + 720, + 164, + 733 + ], + "score": 1.0, + "content": "3321876.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 44, + "bbox_fs": [ + 106, + 676, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Nikolaus Hansen, Sibylle Muller, and Petros Koumoutsakos. Reducing the time complexity of ¨", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 92, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 115, + 92, + 506, + 107 + ], + "score": 1.0, + "content": "the derandomized evolution strategy with covariance matrix adaptation (cma-es). Evolutionary", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 117, + 105, + 247, + 117 + ], + "spans": [ + { + "bbox": [ + 117, + 105, + 247, + 117 + ], + "score": 1.0, + "content": "Computation, 11(1):1–18, 2003.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 106, + 123, + 503, + 156 + ], + "lines": [ + { + "bbox": [ + 106, + 123, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 106, + 123, + 505, + 136 + ], + "score": 1.0, + "content": "Mingyi Hong, Zhi-Quan Luo, and Meisam Razaviyayn. Convergence analysis of alternating direc-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 134, + 505, + 147 + ], + "spans": [ + { + "bbox": [ + 115, + 134, + 505, + 147 + ], + "score": 1.0, + "content": "tion method of multipliers for a family of nonconvex problems. SIAM Journal on Optimization,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 145, + 206, + 157 + ], + "spans": [ + { + "bbox": [ + 115, + 145, + 206, + 157 + ], + "score": 1.0, + "content": "26(1):337–364, 2016.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 105, + 164, + 505, + 187 + ], + "lines": [ + { + "bbox": [ + 106, + 163, + 506, + 177 + ], + "spans": [ + { + "bbox": [ + 106, + 163, + 506, + 177 + ], + "score": 1.0, + "content": "Christian Igel. Neuroevolution for reinforcement learning using evolution strategies. In 2003 IEEE", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 175, + 305, + 187 + ], + "spans": [ + { + "bbox": [ + 116, + 175, + 305, + 187 + ], + "score": 1.0, + "content": "Congress on Evolutionary Computation, 2003.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 106, + 193, + 504, + 217 + ], + "lines": [ + { + "bbox": [ + 107, + 194, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 107, + 194, + 505, + 206 + ], + "score": 1.0, + "content": "Oswin Krause, Didac Arbones, and Christian Igel. Cma-es with optimal covariance update and", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 205, + 491, + 217 + ], + "spans": [ + { + "bbox": [ + 115, + 205, + 491, + 217 + ], + "score": 1.0, + "content": "storage complexity. Advances in Neural Information Processing Systems, pp. 370–378, 2016.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 106, + 223, + 503, + 246 + ], + "lines": [ + { + "bbox": [ + 105, + 222, + 505, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 222, + 505, + 237 + ], + "score": 1.0, + "content": "Alex Kulesza and Ben Taskar. Determinantal point processes for machine learning. Foundations", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 116, + 234, + 345, + 247 + ], + "spans": [ + { + "bbox": [ + 116, + 234, + 345, + 247 + ], + "score": 1.0, + "content": "and Trends in Machine Learning, 5(2-3):123–286, 2012.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 106, + 253, + 505, + 288 + ], + "lines": [ + { + "bbox": [ + 105, + 253, + 504, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 504, + 267 + ], + "score": 1.0, + "content": "Hao Liu, Richard Socher, and Caiming Xiong. Taming MAML: efficient unbiased meta-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 265, + 505, + 277 + ], + "spans": [ + { + "bbox": [ + 116, + 265, + 505, + 277 + ], + "score": 1.0, + "content": "reinforcement learning. In Proceedings of the 36th International Conference on Machine Learn-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 115, + 275, + 464, + 288 + ], + "spans": [ + { + "bbox": [ + 115, + 275, + 464, + 288 + ], + "score": 1.0, + "content": "ing, ICML 2019, 9-15 June 2019, Long Beach, California, USA, pp. 4061–4071, 2019.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 106, + 294, + 504, + 328 + ], + "lines": [ + { + "bbox": [ + 106, + 294, + 506, + 307 + ], + "spans": [ + { + "bbox": [ + 106, + 294, + 506, + 307 + ], + "score": 1.0, + "content": "Ilya Loshchilov and Frank Hutter. SGDR: stochastic gradient descent with warm restarts. In 5th", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 117, + 306, + 504, + 317 + ], + "spans": [ + { + "bbox": [ + 117, + 306, + 504, + 317 + ], + "score": 1.0, + "content": "International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 116, + 316, + 294, + 329 + ], + "spans": [ + { + "bbox": [ + 116, + 316, + 294, + 329 + ], + "score": 1.0, + "content": "2017, Conference Track Proceedings, 2017.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 335, + 505, + 369 + ], + "lines": [ + { + "bbox": [ + 106, + 335, + 505, + 348 + ], + "spans": [ + { + "bbox": [ + 106, + 335, + 505, + 348 + ], + "score": 1.0, + "content": "Horia Mania, Aurelia Guy, and Benjamin Recht. Simple random search provides a competitive", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 115, + 346, + 505, + 360 + ], + "spans": [ + { + "bbox": [ + 115, + 346, + 505, + 360 + ], + "score": 1.0, + "content": "approach to reinforcement learning. Advances in Neural Information Processing Systems 31, pp.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 117, + 358, + 191, + 369 + ], + "spans": [ + { + "bbox": [ + 117, + 358, + 191, + 369 + ], + "score": 1.0, + "content": "1800–1809, 2018.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 106, + 375, + 505, + 399 + ], + "lines": [ + { + "bbox": [ + 106, + 376, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 505, + 389 + ], + "score": 1.0, + "content": "David Moriarty, Alan Schultz, and John Grefenstette. Evolutionary algorithms for reinforcement", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 387, + 405, + 399 + ], + "spans": [ + { + "bbox": [ + 115, + 387, + 405, + 399 + ], + "score": 1.0, + "content": "learning. Journal of Artificial Intelligence Research, 11:241–276, 1999.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5 + }, + { + "type": "text", + "bbox": [ + 106, + 406, + 504, + 429 + ], + "lines": [ + { + "bbox": [ + 106, + 406, + 504, + 419 + ], + "spans": [ + { + "bbox": [ + 106, + 406, + 504, + 419 + ], + "score": 1.0, + "content": "Yurii Nesterov and Vladimir Spokoiny. Random gradient-free minimization of convex functions.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 116, + 417, + 387, + 429 + ], + "spans": [ + { + "bbox": [ + 116, + 417, + 387, + 429 + ], + "score": 1.0, + "content": "Foundations of Computational Mathematics, 17(2):527–566, 2017.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 105, + 435, + 504, + 459 + ], + "lines": [ + { + "bbox": [ + 106, + 435, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 435, + 505, + 448 + ], + "score": 1.0, + "content": "Sebastian Risi and Kenneth Stanley. Deep neuroevolution of recurrent and discrete world models.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 447, + 219, + 458 + ], + "spans": [ + { + "bbox": [ + 115, + 447, + 219, + 458 + ], + "score": 1.0, + "content": "arXiv:1906.08857, 2019.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 106, + 465, + 504, + 500 + ], + "lines": [ + { + "bbox": [ + 105, + 465, + 505, + 479 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 505, + 479 + ], + "score": 1.0, + "content": "Jonas Rothfuss, Dennis Lee, Ignasi Clavera, Tamim Asfour, and Pieter Abbeel. Promp: Proximal", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 477, + 505, + 489 + ], + "spans": [ + { + "bbox": [ + 116, + 477, + 505, + 489 + ], + "score": 1.0, + "content": "meta-policy search. In 7th International Conference on Learning Representations, ICLR 2019,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 116, + 488, + 302, + 500 + ], + "spans": [ + { + "bbox": [ + 116, + 488, + 302, + 500 + ], + "score": 1.0, + "content": "New Orleans, LA, USA, May 6-9, 2019, 2019.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 104, + 506, + 504, + 530 + ], + "lines": [ + { + "bbox": [ + 106, + 506, + 506, + 520 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 506, + 520 + ], + "score": 1.0, + "content": "Tim Salimans, Jonathan Ho, Xi Chen, Szymon Sidor, and Ilya Sutskever. Evolution strategies as a", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 117, + 518, + 405, + 529 + ], + "spans": [ + { + "bbox": [ + 117, + 518, + 405, + 529 + ], + "score": 1.0, + "content": "scalable alternative to reinforcement learning. arXiv:1703.03864, 2017.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5 + }, + { + "type": "text", + "bbox": [ + 107, + 536, + 505, + 571 + ], + "lines": [ + { + "bbox": [ + 106, + 537, + 505, + 548 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 505, + 548 + ], + "score": 1.0, + "content": "Felipe Petroski Such, Vashisht Madhavan, Edoardo Conti, Joel Lehman, Kenneth Stanley, and Jeff", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 546, + 505, + 561 + ], + "spans": [ + { + "bbox": [ + 115, + 546, + 505, + 561 + ], + "score": 1.0, + "content": "Clune. Deep neuroevolution: Genetic algorithms are a competitive alternative for training deep", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 115, + 559, + 397, + 571 + ], + "spans": [ + { + "bbox": [ + 115, + 559, + 397, + 571 + ], + "score": 1.0, + "content": "neural networks for reinforcement learning. arXiv:1712.06567, 2017.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 105, + 577, + 504, + 601 + ], + "lines": [ + { + "bbox": [ + 106, + 577, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 106, + 577, + 505, + 590 + ], + "score": 1.0, + "content": "Christian Wachinger and Polina Golland. Sampling from determinantal point processes for scalable", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 115, + 588, + 457, + 601 + ], + "spans": [ + { + "bbox": [ + 115, + 588, + 457, + 601 + ], + "score": 1.0, + "content": "manifold learning. Information Processing for Medical Imaging, pp. 687–698, 2015.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 105, + 607, + 504, + 631 + ], + "lines": [ + { + "bbox": [ + 105, + 606, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 505, + 621 + ], + "score": 1.0, + "content": "Mengdi Wang, Ji Liu, and Xingyuan Fang. Accelerating stochastic composition optimization. Jour-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 618, + 322, + 631 + ], + "spans": [ + { + "bbox": [ + 115, + 618, + 322, + 631 + ], + "score": 1.0, + "content": "nal of Machine Learning Research, 18:1–23, 2017.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37.5 + }, + { + "type": "text", + "bbox": [ + 105, + 637, + 504, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 636, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 505, + 650 + ], + "score": 1.0, + "content": "Daan Wierstra, Tom Schaul, Jan Peters, and Jurgen Schmidhuber. Natural evolution strategies. In ¨", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 116, + 648, + 416, + 661 + ], + "spans": [ + { + "bbox": [ + 116, + 648, + 416, + 661 + ], + "score": 1.0, + "content": "2008 IEEE Congress on Evolutionary Computation, pp. 3381–3387, 2008.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39.5 + }, + { + "type": "text", + "bbox": [ + 105, + 667, + 504, + 690 + ], + "lines": [ + { + "bbox": [ + 106, + 668, + 504, + 679 + ], + "spans": [ + { + "bbox": [ + 106, + 668, + 504, + 679 + ], + "score": 1.0, + "content": "Daan Wierstra, Tom Schaul, Tobias Glasmachers, Yi Sun, Jan Peters, and Jurgen Schmidhuber. ¨", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 116, + 678, + 471, + 690 + ], + "spans": [ + { + "bbox": [ + 116, + 678, + 471, + 690 + ], + "score": 1.0, + "content": "Natural evolution strategies. Journal of Machine Learning Research, 15:949–980, 2014.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + }, + { + "type": "text", + "bbox": [ + 108, + 697, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 697, + 506, + 709 + ], + "spans": [ + { + "bbox": [ + 106, + 697, + 506, + 709 + ], + "score": 1.0, + "content": "Yuxiang Yang, Ken Caluwaerts, Atil Iscen, Jie Tan, and Chelsea Finn. Norml: No-reward meta", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 116, + 709, + 505, + 720 + ], + "spans": [ + { + "bbox": [ + 116, + 709, + 505, + 720 + ], + "score": 1.0, + "content": "learning. In Proceedings of the 18th International Conference on Autonomous Agents and Multi-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 718, + 481, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 718, + 481, + 732 + ], + "score": 1.0, + "content": "Agent Systems, AAMAS ’19, Montreal, QC, Canada, May 13-17, 2019, pp. 323–331, 2019.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 294, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Nikolaus Hansen, Sibylle Muller, and Petros Koumoutsakos. Reducing the time complexity of ¨", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 92, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 115, + 92, + 506, + 107 + ], + "score": 1.0, + "content": "the derandomized evolution strategy with covariance matrix adaptation (cma-es). Evolutionary", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 117, + 105, + 247, + 117 + ], + "spans": [ + { + "bbox": [ + 117, + 105, + 247, + 117 + ], + "score": 1.0, + "content": "Computation, 11(1):1–18, 2003.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 106, + 82, + 506, + 117 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 123, + 503, + 156 + ], + "lines": [ + { + "bbox": [ + 106, + 123, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 106, + 123, + 505, + 136 + ], + "score": 1.0, + "content": "Mingyi Hong, Zhi-Quan Luo, and Meisam Razaviyayn. Convergence analysis of alternating direc-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 134, + 505, + 147 + ], + "spans": [ + { + "bbox": [ + 115, + 134, + 505, + 147 + ], + "score": 1.0, + "content": "tion method of multipliers for a family of nonconvex problems. SIAM Journal on Optimization,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 145, + 206, + 157 + ], + "spans": [ + { + "bbox": [ + 115, + 145, + 206, + 157 + ], + "score": 1.0, + "content": "26(1):337–364, 2016.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4, + "bbox_fs": [ + 106, + 123, + 505, + 157 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 164, + 505, + 187 + ], + "lines": [ + { + "bbox": [ + 106, + 163, + 506, + 177 + ], + "spans": [ + { + "bbox": [ + 106, + 163, + 506, + 177 + ], + "score": 1.0, + "content": "Christian Igel. Neuroevolution for reinforcement learning using evolution strategies. In 2003 IEEE", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 175, + 305, + 187 + ], + "spans": [ + { + "bbox": [ + 116, + 175, + 305, + 187 + ], + "score": 1.0, + "content": "Congress on Evolutionary Computation, 2003.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5, + "bbox_fs": [ + 106, + 163, + 506, + 187 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 193, + 504, + 217 + ], + "lines": [ + { + "bbox": [ + 107, + 194, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 107, + 194, + 505, + 206 + ], + "score": 1.0, + "content": "Oswin Krause, Didac Arbones, and Christian Igel. Cma-es with optimal covariance update and", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 205, + 491, + 217 + ], + "spans": [ + { + "bbox": [ + 115, + 205, + 491, + 217 + ], + "score": 1.0, + "content": "storage complexity. Advances in Neural Information Processing Systems, pp. 370–378, 2016.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5, + "bbox_fs": [ + 107, + 194, + 505, + 217 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 223, + 503, + 246 + ], + "lines": [ + { + "bbox": [ + 105, + 222, + 505, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 222, + 505, + 237 + ], + "score": 1.0, + "content": "Alex Kulesza and Ben Taskar. Determinantal point processes for machine learning. Foundations", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 116, + 234, + 345, + 247 + ], + "spans": [ + { + "bbox": [ + 116, + 234, + 345, + 247 + ], + "score": 1.0, + "content": "and Trends in Machine Learning, 5(2-3):123–286, 2012.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 222, + 505, + 247 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 253, + 505, + 288 + ], + "lines": [ + { + "bbox": [ + 105, + 253, + 504, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 504, + 267 + ], + "score": 1.0, + "content": "Hao Liu, Richard Socher, and Caiming Xiong. Taming MAML: efficient unbiased meta-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 265, + 505, + 277 + ], + "spans": [ + { + "bbox": [ + 116, + 265, + 505, + 277 + ], + "score": 1.0, + "content": "reinforcement learning. In Proceedings of the 36th International Conference on Machine Learn-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 115, + 275, + 464, + 288 + ], + "spans": [ + { + "bbox": [ + 115, + 275, + 464, + 288 + ], + "score": 1.0, + "content": "ing, ICML 2019, 9-15 June 2019, Long Beach, California, USA, pp. 4061–4071, 2019.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13, + "bbox_fs": [ + 105, + 253, + 505, + 288 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 294, + 504, + 328 + ], + "lines": [ + { + "bbox": [ + 106, + 294, + 506, + 307 + ], + "spans": [ + { + "bbox": [ + 106, + 294, + 506, + 307 + ], + "score": 1.0, + "content": "Ilya Loshchilov and Frank Hutter. SGDR: stochastic gradient descent with warm restarts. In 5th", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 117, + 306, + 504, + 317 + ], + "spans": [ + { + "bbox": [ + 117, + 306, + 504, + 317 + ], + "score": 1.0, + "content": "International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 116, + 316, + 294, + 329 + ], + "spans": [ + { + "bbox": [ + 116, + 316, + 294, + 329 + ], + "score": 1.0, + "content": "2017, Conference Track Proceedings, 2017.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16, + "bbox_fs": [ + 106, + 294, + 506, + 329 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 335, + 505, + 369 + ], + "lines": [ + { + "bbox": [ + 106, + 335, + 505, + 348 + ], + "spans": [ + { + "bbox": [ + 106, + 335, + 505, + 348 + ], + "score": 1.0, + "content": "Horia Mania, Aurelia Guy, and Benjamin Recht. Simple random search provides a competitive", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 115, + 346, + 505, + 360 + ], + "spans": [ + { + "bbox": [ + 115, + 346, + 505, + 360 + ], + "score": 1.0, + "content": "approach to reinforcement learning. Advances in Neural Information Processing Systems 31, pp.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 117, + 358, + 191, + 369 + ], + "spans": [ + { + "bbox": [ + 117, + 358, + 191, + 369 + ], + "score": 1.0, + "content": "1800–1809, 2018.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19, + "bbox_fs": [ + 106, + 335, + 505, + 369 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 375, + 505, + 399 + ], + "lines": [ + { + "bbox": [ + 106, + 376, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 505, + 389 + ], + "score": 1.0, + "content": "David Moriarty, Alan Schultz, and John Grefenstette. Evolutionary algorithms for reinforcement", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 387, + 405, + 399 + ], + "spans": [ + { + "bbox": [ + 115, + 387, + 405, + 399 + ], + "score": 1.0, + "content": "learning. Journal of Artificial Intelligence Research, 11:241–276, 1999.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5, + "bbox_fs": [ + 106, + 376, + 505, + 399 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 406, + 504, + 429 + ], + "lines": [ + { + "bbox": [ + 106, + 406, + 504, + 419 + ], + "spans": [ + { + "bbox": [ + 106, + 406, + 504, + 419 + ], + "score": 1.0, + "content": "Yurii Nesterov and Vladimir Spokoiny. Random gradient-free minimization of convex functions.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 116, + 417, + 387, + 429 + ], + "spans": [ + { + "bbox": [ + 116, + 417, + 387, + 429 + ], + "score": 1.0, + "content": "Foundations of Computational Mathematics, 17(2):527–566, 2017.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5, + "bbox_fs": [ + 106, + 406, + 504, + 429 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 435, + 504, + 459 + ], + "lines": [ + { + "bbox": [ + 106, + 435, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 435, + 505, + 448 + ], + "score": 1.0, + "content": "Sebastian Risi and Kenneth Stanley. Deep neuroevolution of recurrent and discrete world models.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 447, + 219, + 458 + ], + "spans": [ + { + "bbox": [ + 115, + 447, + 219, + 458 + ], + "score": 1.0, + "content": "arXiv:1906.08857, 2019.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5, + "bbox_fs": [ + 106, + 435, + 505, + 458 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 465, + 504, + 500 + ], + "lines": [ + { + "bbox": [ + 105, + 465, + 505, + 479 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 505, + 479 + ], + "score": 1.0, + "content": "Jonas Rothfuss, Dennis Lee, Ignasi Clavera, Tamim Asfour, and Pieter Abbeel. Promp: Proximal", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 477, + 505, + 489 + ], + "spans": [ + { + "bbox": [ + 116, + 477, + 505, + 489 + ], + "score": 1.0, + "content": "meta-policy search. In 7th International Conference on Learning Representations, ICLR 2019,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 116, + 488, + 302, + 500 + ], + "spans": [ + { + "bbox": [ + 116, + 488, + 302, + 500 + ], + "score": 1.0, + "content": "New Orleans, LA, USA, May 6-9, 2019, 2019.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28, + "bbox_fs": [ + 105, + 465, + 505, + 500 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 506, + 504, + 530 + ], + "lines": [ + { + "bbox": [ + 106, + 506, + 506, + 520 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 506, + 520 + ], + "score": 1.0, + "content": "Tim Salimans, Jonathan Ho, Xi Chen, Szymon Sidor, and Ilya Sutskever. Evolution strategies as a", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 117, + 518, + 405, + 529 + ], + "spans": [ + { + "bbox": [ + 117, + 518, + 405, + 529 + ], + "score": 1.0, + "content": "scalable alternative to reinforcement learning. arXiv:1703.03864, 2017.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5, + "bbox_fs": [ + 106, + 506, + 506, + 529 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 536, + 505, + 571 + ], + "lines": [ + { + "bbox": [ + 106, + 537, + 505, + 548 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 505, + 548 + ], + "score": 1.0, + "content": "Felipe Petroski Such, Vashisht Madhavan, Edoardo Conti, Joel Lehman, Kenneth Stanley, and Jeff", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 546, + 505, + 561 + ], + "spans": [ + { + "bbox": [ + 115, + 546, + 505, + 561 + ], + "score": 1.0, + "content": "Clune. Deep neuroevolution: Genetic algorithms are a competitive alternative for training deep", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 115, + 559, + 397, + 571 + ], + "spans": [ + { + "bbox": [ + 115, + 559, + 397, + 571 + ], + "score": 1.0, + "content": "neural networks for reinforcement learning. arXiv:1712.06567, 2017.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33, + "bbox_fs": [ + 106, + 537, + 505, + 571 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 577, + 504, + 601 + ], + "lines": [ + { + "bbox": [ + 106, + 577, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 106, + 577, + 505, + 590 + ], + "score": 1.0, + "content": "Christian Wachinger and Polina Golland. Sampling from determinantal point processes for scalable", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 115, + 588, + 457, + 601 + ], + "spans": [ + { + "bbox": [ + 115, + 588, + 457, + 601 + ], + "score": 1.0, + "content": "manifold learning. Information Processing for Medical Imaging, pp. 687–698, 2015.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5, + "bbox_fs": [ + 106, + 577, + 505, + 601 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 607, + 504, + 631 + ], + "lines": [ + { + "bbox": [ + 105, + 606, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 505, + 621 + ], + "score": 1.0, + "content": "Mengdi Wang, Ji Liu, and Xingyuan Fang. Accelerating stochastic composition optimization. Jour-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 618, + 322, + 631 + ], + "spans": [ + { + "bbox": [ + 115, + 618, + 322, + 631 + ], + "score": 1.0, + "content": "nal of Machine Learning Research, 18:1–23, 2017.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37.5, + "bbox_fs": [ + 105, + 606, + 505, + 631 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 637, + 504, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 636, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 505, + 650 + ], + "score": 1.0, + "content": "Daan Wierstra, Tom Schaul, Jan Peters, and Jurgen Schmidhuber. Natural evolution strategies. In ¨", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 116, + 648, + 416, + 661 + ], + "spans": [ + { + "bbox": [ + 116, + 648, + 416, + 661 + ], + "score": 1.0, + "content": "2008 IEEE Congress on Evolutionary Computation, pp. 3381–3387, 2008.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39.5, + "bbox_fs": [ + 105, + 636, + 505, + 661 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 667, + 504, + 690 + ], + "lines": [ + { + "bbox": [ + 106, + 668, + 504, + 679 + ], + "spans": [ + { + "bbox": [ + 106, + 668, + 504, + 679 + ], + "score": 1.0, + "content": "Daan Wierstra, Tom Schaul, Tobias Glasmachers, Yi Sun, Jan Peters, and Jurgen Schmidhuber. ¨", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 116, + 678, + 471, + 690 + ], + "spans": [ + { + "bbox": [ + 116, + 678, + 471, + 690 + ], + "score": 1.0, + "content": "Natural evolution strategies. Journal of Machine Learning Research, 15:949–980, 2014.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5, + "bbox_fs": [ + 106, + 668, + 504, + 690 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 697, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 697, + 506, + 709 + ], + "spans": [ + { + "bbox": [ + 106, + 697, + 506, + 709 + ], + "score": 1.0, + "content": "Yuxiang Yang, Ken Caluwaerts, Atil Iscen, Jie Tan, and Chelsea Finn. Norml: No-reward meta", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 116, + 709, + 505, + 720 + ], + "spans": [ + { + "bbox": [ + 116, + 709, + 505, + 720 + ], + "score": 1.0, + "content": "learning. In Proceedings of the 18th International Conference on Autonomous Agents and Multi-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 718, + 481, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 718, + 481, + 732 + ], + "score": 1.0, + "content": "Agent Systems, AAMAS ’19, Montreal, QC, Canada, May 13-17, 2019, pp. 323–331, 2019.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44, + "bbox_fs": [ + 106, + 697, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 80, + 272, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 80, + 273, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 80, + 273, + 96 + ], + "score": 1.0, + "content": "A.1 FIRST-ORDER ES-MAML", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 108, + 105, + 197, + 117 + ], + "lines": [ + { + "bbox": [ + 106, + 105, + 198, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 198, + 118 + ], + "score": 1.0, + "content": "A.1.1 ALGORITHM", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 126, + 505, + 176 + ], + "lines": [ + { + "bbox": [ + 105, + 126, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 505, + 140 + ], + "score": 1.0, + "content": "Suppose that we first apply Gaussian smoothing to the task rewards and then form the MAML", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 137, + 506, + 153 + ], + "spans": [ + { + "bbox": [ + 105, + 138, + 190, + 153 + ], + "score": 1.0, + "content": "problem, so we have", + "type": "text" + }, + { + "bbox": [ + 190, + 137, + 314, + 153 + ], + "score": 0.94, + "content": "J ( \\tilde { \\theta } ) = \\mathbb { E } _ { T \\sim \\mathcal { P } ( T ) } \\tilde { f } ^ { T } ( U ( \\theta , \\hat { T } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 138, + 371, + 153 + ], + "score": 1.0, + "content": ". The function", + "type": "text" + }, + { + "bbox": [ + 371, + 140, + 379, + 149 + ], + "score": 0.81, + "content": "J", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 138, + 506, + 153 + ], + "score": 1.0, + "content": "is then itself differentiable, and", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 104, + 151, + 504, + 168 + ], + "spans": [ + { + "bbox": [ + 104, + 151, + 399, + 168 + ], + "score": 1.0, + "content": "we can directly apply first-order methods to it. The classical case where", + "type": "text" + }, + { + "bbox": [ + 399, + 151, + 504, + 166 + ], + "score": 0.92, + "content": "U ( \\theta , T ) = \\theta + \\alpha \\nabla \\widetilde { f } ^ { T } ( \\theta )", + "type": "inline_equation" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 165, + 183, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 183, + 178 + ], + "score": 1.0, + "content": "yields the gradient", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5 + }, + { + "type": "interline_equation", + "bbox": [ + 186, + 178, + 424, + 195 + ], + "lines": [ + { + "bbox": [ + 186, + 178, + 424, + 195 + ], + "spans": [ + { + "bbox": [ + 186, + 178, + 424, + 195 + ], + "score": 0.9, + "content": "\\nabla J ( \\theta ) = \\mathbb { E } _ { T \\sim \\mathcal { P } ( \\mathcal { T } ) } \\nabla \\widetilde { f } ^ { T } ( \\theta + \\alpha \\nabla \\widetilde { f } ^ { T } ( \\theta ) ) ( \\mathbf { I } + \\alpha \\nabla ^ { 2 } \\widetilde { f } ^ { T } ( \\theta ) ) .", + "type": "interline_equation", + "image_path": "651d787182521ed9ad2d9eb72c2b88016d2adaa520df98ff45a5244f11921f0c.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 186, + 178, + 424, + 195 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 197, + 506, + 231 + ], + "lines": [ + { + "bbox": [ + 105, + 196, + 506, + 210 + ], + "spans": [ + { + "bbox": [ + 105, + 196, + 506, + 210 + ], + "score": 1.0, + "content": "This is analogous to formulas obtained in e.g (Liu et al., 2019) for the policy gradient MAML. We", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 209, + 505, + 221 + ], + "spans": [ + { + "bbox": [ + 106, + 209, + 505, + 221 + ], + "score": 1.0, + "content": "can then approximate this gradient as an input to stochastic first-order methods. An example with", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 220, + 267, + 231 + ], + "spans": [ + { + "bbox": [ + 106, + 220, + 267, + 231 + ], + "score": 1.0, + "content": "standard SGD is shown in Algorithm 5.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 299, + 238, + 492, + 388 + ], + "lines": [ + { + "bbox": [ + 308, + 237, + 491, + 251 + ], + "spans": [ + { + "bbox": [ + 308, + 237, + 388, + 251 + ], + "score": 1.0, + "content": "Data: initial policy", + "type": "text" + }, + { + "bbox": [ + 388, + 239, + 398, + 250 + ], + "score": 0.88, + "content": "\\theta _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 237, + 483, + 251 + ], + "score": 1.0, + "content": ", adaptation step size", + "type": "text" + }, + { + "bbox": [ + 483, + 241, + 491, + 248 + ], + "score": 0.77, + "content": "\\alpha", + "type": "inline_equation" + } + ], + "index": 10 + }, + { + "bbox": [ + 334, + 249, + 491, + 261 + ], + "spans": [ + { + "bbox": [ + 334, + 249, + 393, + 261 + ], + "score": 1.0, + "content": "meta step size", + "type": "text" + }, + { + "bbox": [ + 394, + 250, + 401, + 261 + ], + "score": 0.83, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 249, + 480, + 261 + ], + "score": 1.0, + "content": ", number of queries", + "type": "text" + }, + { + "bbox": [ + 480, + 250, + 491, + 259 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + } + ], + "index": 11 + }, + { + "bbox": [ + 300, + 260, + 387, + 272 + ], + "spans": [ + { + "bbox": [ + 300, + 260, + 323, + 272 + ], + "score": 1.0, + "content": "1 for", + "type": "text" + }, + { + "bbox": [ + 324, + 261, + 379, + 272 + ], + "score": 0.59, + "content": "t = 0 , 1 , \\ldots { } \\mathbf { d }", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 260, + 387, + 272 + ], + "score": 1.0, + "content": "o", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 300, + 269, + 437, + 285 + ], + "spans": [ + { + "bbox": [ + 300, + 274, + 306, + 281 + ], + "score": 1.0, + "content": "2", + "type": "text" + }, + { + "bbox": [ + 321, + 269, + 356, + 285 + ], + "score": 1.0, + "content": "Sample", + "type": "text" + }, + { + "bbox": [ + 356, + 273, + 364, + 281 + ], + "score": 0.77, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 269, + 387, + 285 + ], + "score": 1.0, + "content": "tasks", + "type": "text" + }, + { + "bbox": [ + 387, + 271, + 432, + 282 + ], + "score": 0.91, + "content": "T _ { 1 } , \\ldots , T _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 269, + 437, + 285 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 300, + 281, + 384, + 294 + ], + "spans": [ + { + "bbox": [ + 300, + 285, + 306, + 294 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 323, + 281, + 357, + 294 + ], + "score": 1.0, + "content": "foreach", + "type": "text" + }, + { + "bbox": [ + 358, + 283, + 368, + 293 + ], + "score": 0.82, + "content": "T _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 281, + 384, + 294 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 300, + 291, + 474, + 310 + ], + "spans": [ + { + "bbox": [ + 300, + 299, + 307, + 308 + ], + "score": 1.0, + "content": "4", + "type": "text" + }, + { + "bbox": [ + 338, + 294, + 469, + 308 + ], + "score": 0.64, + "content": "\\mathbf { d } _ { 1 } ^ { ( i ) } \\mathrm { E S G R A D } ( f ^ { T _ { i } } , \\theta _ { t } , K , \\sigma )", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 291, + 474, + 310 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 300, + 309, + 469, + 321 + ], + "spans": [ + { + "bbox": [ + 300, + 311, + 307, + 321 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 338, + 309, + 469, + 321 + ], + "score": 0.52, + "content": "\\mathbf { H } ^ { ( i ) } \\gets \\mathrm { E S H E S S } ( f ^ { T _ { i } } , \\theta _ { t } , K , \\sigma ) ;", + "type": "inline_equation" + } + ], + "index": 19 + }, + { + "bbox": [ + 300, + 319, + 419, + 338 + ], + "spans": [ + { + "bbox": [ + 300, + 326, + 307, + 335 + ], + "score": 1.0, + "content": "6", + "type": "text" + }, + { + "bbox": [ + 339, + 322, + 414, + 335 + ], + "score": 0.51, + "content": "\\boldsymbol { \\theta } _ { t } ^ { ( i ) } \\boldsymbol { \\theta } _ { t } + \\alpha \\cdot \\mathbf { d } _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 319, + 419, + 338 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 299, + 332, + 481, + 353 + ], + "spans": [ + { + "bbox": [ + 299, + 341, + 307, + 350 + ], + "score": 1.0, + "content": "7", + "type": "text" + }, + { + "bbox": [ + 338, + 336, + 476, + 351 + ], + "score": 0.47, + "content": "\\mathbf { d } _ { 2 } ^ { ( i ) } \\gets \\mathrm { E S G R A D } ( f ^ { T _ { i } } , \\theta _ { t } ^ { ( i ) } , K , \\sigma ) ;", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 332, + 481, + 353 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 299, + 349, + 343, + 362 + ], + "spans": [ + { + "bbox": [ + 299, + 352, + 307, + 362 + ], + "score": 1.0, + "content": "8", + "type": "text" + }, + { + "bbox": [ + 322, + 349, + 343, + 362 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 299, + 362, + 478, + 379 + ], + "spans": [ + { + "bbox": [ + 299, + 367, + 307, + 376 + ], + "score": 1.0, + "content": "9", + "type": "text" + }, + { + "bbox": [ + 324, + 362, + 478, + 379 + ], + "score": 0.55, + "content": "\\begin{array} { r } { \\theta _ { t + 1 } \\theta _ { t } + \\frac { \\beta } { n } \\sum _ { i = 1 } ^ { n } ( \\mathbf { I } + \\alpha \\mathbf { H } ^ { ( i ) } ) \\mathbf { d } _ { 2 } ^ { ( i ) } ; } \\end{array}", + "type": "inline_equation" + } + ], + "index": 27 + }, + { + "bbox": [ + 295, + 377, + 327, + 389 + ], + "spans": [ + { + "bbox": [ + 295, + 377, + 327, + 389 + ], + "score": 1.0, + "content": "10 end", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 18.5 + }, + { + "type": "text", + "bbox": [ + 97, + 272, + 285, + 367 + ], + "lines": [ + { + "bbox": [ + 97, + 271, + 186, + 286 + ], + "spans": [ + { + "bbox": [ + 97, + 271, + 141, + 286 + ], + "score": 1.0, + "content": "1 ESHess", + "type": "text" + }, + { + "bbox": [ + 142, + 273, + 186, + 285 + ], + "score": 0.9, + "content": "( f , \\theta , n , \\sigma )", + "type": "inline_equation" + } + ], + "index": 13 + }, + { + "bbox": [ + 120, + 282, + 282, + 295 + ], + "spans": [ + { + "bbox": [ + 120, + 282, + 190, + 295 + ], + "score": 1.0, + "content": "inputs: function", + "type": "text" + }, + { + "bbox": [ + 190, + 284, + 197, + 295 + ], + "score": 0.84, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 282, + 228, + 295 + ], + "score": 1.0, + "content": ", policy", + "type": "text" + }, + { + "bbox": [ + 228, + 284, + 234, + 293 + ], + "score": 0.79, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 282, + 282, + 295 + ], + "score": 1.0, + "content": ", number of", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 152, + 294, + 267, + 306 + ], + "spans": [ + { + "bbox": [ + 152, + 294, + 209, + 306 + ], + "score": 1.0, + "content": "perturbations", + "type": "text" + }, + { + "bbox": [ + 209, + 297, + 216, + 304 + ], + "score": 0.75, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 294, + 259, + 306 + ], + "score": 1.0, + "content": ", precision", + "type": "text" + }, + { + "bbox": [ + 259, + 297, + 267, + 304 + ], + "score": 0.73, + "content": "\\sigma", + "type": "inline_equation" + } + ], + "index": 15 + }, + { + "bbox": [ + 97, + 303, + 286, + 336 + ], + "spans": [ + { + "bbox": [ + 97, + 308, + 105, + 329 + ], + "score": 1.0, + "content": "2 3", + "type": "text" + }, + { + "bbox": [ + 122, + 316, + 224, + 330 + ], + "score": 0.85, + "content": "\\textstyle v \\gets { \\frac { 1 } { n } } \\sum _ { i = 1 } ^ { n } f ( \\theta + \\sigma \\mathbf { g } _ { i } )", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 305, + 204, + 317 + ], + "score": 0.93, + "content": "\\mathcal { N } ( 0 , \\bf { I } )", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 303, + 237, + 336 + ], + "score": 1.0, + "content": "ors ;", + "type": "text" + }, + { + "bbox": [ + 237, + 307, + 281, + 317 + ], + "score": 0.88, + "content": "\\mathbf { g } _ { 1 } , \\ldots , \\mathbf { g } _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 282, + 303, + 286, + 336 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 98, + 324, + 262, + 348 + ], + "spans": [ + { + "bbox": [ + 98, + 334, + 104, + 341 + ], + "score": 1.0, + "content": "4", + "type": "text" + }, + { + "bbox": [ + 122, + 330, + 254, + 343 + ], + "score": 0.87, + "content": "\\begin{array} { r } { \\mathbf { H } ^ { 0 } \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } f ( \\theta + \\sigma \\mathbf { g } _ { i } ) \\mathbf { g } _ { i } \\mathbf { g } _ { i } ^ { T } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 324, + 262, + 348 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 98, + 342, + 219, + 357 + ], + "spans": [ + { + "bbox": [ + 98, + 347, + 104, + 354 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 119, + 342, + 152, + 357 + ], + "score": 1.0, + "content": "return", + "type": "text" + }, + { + "bbox": [ + 152, + 343, + 214, + 356 + ], + "score": 0.89, + "content": "\\begin{array} { r } { \\frac { 1 } { \\sigma ^ { 2 } } ( \\mathbf { H } ^ { 0 } - v \\cdot \\mathbf { I } ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 342, + 219, + 357 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 126, + 354, + 286, + 366 + ], + "spans": [ + { + "bbox": [ + 126, + 354, + 286, + 366 + ], + "score": 1.0, + "content": "Algorithm 4: Monte Carlo ES Hessian", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 331, + 389, + 482, + 400 + ], + "lines": [ + { + "bbox": [ + 331, + 388, + 482, + 401 + ], + "spans": [ + { + "bbox": [ + 331, + 388, + 482, + 401 + ], + "score": 1.0, + "content": "Algorithm 5: First Order ES-MAML", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 406, + 506, + 432 + ], + "lines": [ + { + "bbox": [ + 106, + 406, + 506, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 406, + 506, + 420 + ], + "score": 1.0, + "content": "A central problem, as discussed in (Rothfuss et al., 2019; Liu et al., 2019) is the estimation of", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 417, + 506, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 418, + 145, + 432 + ], + "score": 0.92, + "content": "\\nabla ^ { 2 } \\widetilde { f } ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 417, + 506, + 435 + ], + "score": 1.0, + "content": ". However, a simple expression exists for this object in the ES setting; it can be shown that", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5 + }, + { + "type": "interline_equation", + "bbox": [ + 188, + 434, + 423, + 458 + ], + "lines": [ + { + "bbox": [ + 188, + 434, + 423, + 458 + ], + "spans": [ + { + "bbox": [ + 188, + 434, + 423, + 458 + ], + "score": 0.93, + "content": "\\nabla ^ { 2 } \\widetilde { f } ^ { T } ( \\theta ) = \\frac { 1 } { \\sigma ^ { 2 } } ( \\mathbb { E } _ { \\mathbf { h } \\sim \\mathcal { N } ( 0 , \\mathbf { I } ) } [ f ^ { T } ( \\theta + \\sigma \\mathbf { h } ) \\mathbf { h } \\mathbf { h } ^ { T } ] - \\widetilde { f } ^ { T } ( \\theta ) \\mathbf { I } ] .", + "type": "interline_equation", + "image_path": "2b139dbfffb12608adb955bc82ca40935c271d49f8fdf2a722cb5c9ad7ae0a2a.jpg" + } + ] + } + ], + "index": 32, + "virtual_lines": [ + { + "bbox": [ + 188, + 434, + 423, + 458 + ], + "spans": [], + "index": 32 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 461, + 505, + 497 + ], + "lines": [ + { + "bbox": [ + 105, + 460, + 506, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 203, + 474 + ], + "score": 1.0, + "content": "Note that for the vector", + "type": "text" + }, + { + "bbox": [ + 203, + 462, + 210, + 472 + ], + "score": 0.36, + "content": "\\mathbf { h }", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 460, + 214, + 474 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 214, + 461, + 228, + 473 + ], + "score": 0.84, + "content": "\\mathbf { h } ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 460, + 388, + 474 + ], + "score": 1.0, + "content": "is the transpose (and unrelated to tasks", + "type": "text" + }, + { + "bbox": [ + 388, + 462, + 397, + 472 + ], + "score": 0.76, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 460, + 506, + 474 + ], + "score": 1.0, + "content": "). A basic MC estimator is", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 473, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 344, + 487 + ], + "score": 1.0, + "content": "shown in Algorithm 4. Given an independent estimator for", + "type": "text" + }, + { + "bbox": [ + 345, + 473, + 431, + 487 + ], + "score": 0.94, + "content": "\\nabla \\widetilde { f } ^ { T } ( \\theta + \\alpha \\nabla \\widetilde { f } ^ { T } ( \\theta ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 431, + 474, + 505, + 487 + ], + "score": 1.0, + "content": ", we can then take", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 486, + 277, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 257, + 497 + ], + "score": 1.0, + "content": "the product to obtain an estimator for", + "type": "text" + }, + { + "bbox": [ + 258, + 486, + 273, + 496 + ], + "score": 0.83, + "content": "\\nabla J", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 486, + 277, + 497 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34 + }, + { + "type": "title", + "bbox": [ + 106, + 510, + 343, + 522 + ], + "lines": [ + { + "bbox": [ + 106, + 510, + 344, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 510, + 344, + 523 + ], + "score": 1.0, + "content": "A.1.2 EXPERIMENTS WITH FIRST-ORDER ES-MAML", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 36 + }, + { + "type": "text", + "bbox": [ + 107, + 530, + 505, + 578 + ], + "lines": [ + { + "bbox": [ + 105, + 530, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 505, + 543 + ], + "score": 1.0, + "content": "Unlike zero-order ES-MAML (Algorithm 3), the first-order ES-MAML explicitly builds an approx-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 541, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 214, + 554 + ], + "score": 1.0, + "content": "imation of the Hessian of", + "type": "text" + }, + { + "bbox": [ + 214, + 541, + 227, + 554 + ], + "score": 0.9, + "content": "f ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 541, + 505, + 554 + ], + "score": 1.0, + "content": ". Given the literature on PG-MAML, we expect that estimating the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 553, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 553, + 140, + 568 + ], + "score": 1.0, + "content": "Hessian", + "type": "text" + }, + { + "bbox": [ + 141, + 553, + 179, + 567 + ], + "score": 0.93, + "content": "\\nabla ^ { 2 } \\widetilde { f } ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 180, + 553, + 505, + 568 + ], + "score": 1.0, + "content": "with Algorithm 4 without any control variates may have high variance. We com-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 566, + 282, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 282, + 578 + ], + "score": 1.0, + "content": "pare two variants of first-order ES-MAML:", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38.5 + }, + { + "type": "text", + "bbox": [ + 128, + 585, + 505, + 641 + ], + "lines": [ + { + "bbox": [ + 130, + 585, + 367, + 598 + ], + "spans": [ + { + "bbox": [ + 130, + 585, + 367, + 598 + ], + "score": 1.0, + "content": "1. The full version (FO-Hessian) specified in Algorithm 5.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 128, + 600, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 128, + 601, + 429, + 614 + ], + "score": 1.0, + "content": "2. The ‘first-order approximation’ (FO-NoHessian) which ignores the term", + "type": "text" + }, + { + "bbox": [ + 429, + 600, + 487, + 614 + ], + "score": 0.94, + "content": "\\mathbf { I } + \\alpha \\nabla ^ { 2 } \\widetilde { f } ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 601, + 506, + 614 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 141, + 613, + 506, + 629 + ], + "spans": [ + { + "bbox": [ + 141, + 615, + 293, + 628 + ], + "score": 1.0, + "content": "approximates the MAML gradient as", + "type": "text" + }, + { + "bbox": [ + 293, + 613, + 417, + 629 + ], + "score": 0.94, + "content": "\\mathbb { E } _ { T \\sim \\mathcal { P } ( \\mathcal { T } ) } \\nabla \\widetilde { f } ^ { T } ( \\theta + \\alpha \\nabla \\widetilde { f } ^ { T } ( \\theta ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 418, + 615, + 506, + 628 + ], + "score": 1.0, + "content": ". This is equivalent to", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 141, + 627, + 311, + 641 + ], + "spans": [ + { + "bbox": [ + 141, + 628, + 171, + 641 + ], + "score": 1.0, + "content": "setting", + "type": "text" + }, + { + "bbox": [ + 172, + 627, + 209, + 639 + ], + "score": 0.91, + "content": "\\mathbf { H } ^ { ( i ) } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 628, + 311, + 641 + ], + "score": 1.0, + "content": "in line 5 of Algorithm 5.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 42.5 + }, + { + "type": "text", + "bbox": [ + 107, + 648, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 106, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "The results on the four corner exploration problem (Section 4.1) and the Forward-Backward Ant,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 659, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 505, + 673 + ], + "score": 1.0, + "content": "using Linear policies, are shown in Figure A1. On Forward-Backward Ant, FO-NoHessian actually", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "score": 1.0, + "content": "outperformed FO-Hessian, so the inclusion of the Hessian term actually slowed convergence. On", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 680, + 505, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 505, + 695 + ], + "score": 1.0, + "content": "the four corners task, both FO-Hessian and FO-NoHessian have large error bars, and FO-Hessian", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 693, + 254, + 705 + ], + "spans": [ + { + "bbox": [ + 106, + 693, + 254, + 705 + ], + "score": 1.0, + "content": "slightly outperforms FO-NoHessian.", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 47 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "There is conflicting evidence as to whether the same phenomenon occurs with PG-MAML; (Finn", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 720, + 504, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 504, + 732 + ], + "score": 1.0, + "content": "et al., 2017, §5.2) found that on supervised learning MAML, omitting Hessian terms is competitive", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 50.5 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 26, + 294, + 38 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 39 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 39 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "12", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 80, + 272, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 80, + 273, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 80, + 273, + 96 + ], + "score": 1.0, + "content": "A.1 FIRST-ORDER ES-MAML", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 108, + 105, + 197, + 117 + ], + "lines": [ + { + "bbox": [ + 106, + 105, + 198, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 198, + 118 + ], + "score": 1.0, + "content": "A.1.1 ALGORITHM", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 126, + 505, + 176 + ], + "lines": [ + { + "bbox": [ + 105, + 126, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 505, + 140 + ], + "score": 1.0, + "content": "Suppose that we first apply Gaussian smoothing to the task rewards and then form the MAML", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 137, + 506, + 153 + ], + "spans": [ + { + "bbox": [ + 105, + 138, + 190, + 153 + ], + "score": 1.0, + "content": "problem, so we have", + "type": "text" + }, + { + "bbox": [ + 190, + 137, + 314, + 153 + ], + "score": 0.94, + "content": "J ( \\tilde { \\theta } ) = \\mathbb { E } _ { T \\sim \\mathcal { P } ( T ) } \\tilde { f } ^ { T } ( U ( \\theta , \\hat { T } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 138, + 371, + 153 + ], + "score": 1.0, + "content": ". The function", + "type": "text" + }, + { + "bbox": [ + 371, + 140, + 379, + 149 + ], + "score": 0.81, + "content": "J", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 138, + 506, + 153 + ], + "score": 1.0, + "content": "is then itself differentiable, and", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 104, + 151, + 504, + 168 + ], + "spans": [ + { + "bbox": [ + 104, + 151, + 399, + 168 + ], + "score": 1.0, + "content": "we can directly apply first-order methods to it. The classical case where", + "type": "text" + }, + { + "bbox": [ + 399, + 151, + 504, + 166 + ], + "score": 0.92, + "content": "U ( \\theta , T ) = \\theta + \\alpha \\nabla \\widetilde { f } ^ { T } ( \\theta )", + "type": "inline_equation" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 165, + 183, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 183, + 178 + ], + "score": 1.0, + "content": "yields the gradient", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5, + "bbox_fs": [ + 104, + 126, + 506, + 178 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 186, + 178, + 424, + 195 + ], + "lines": [ + { + "bbox": [ + 186, + 178, + 424, + 195 + ], + "spans": [ + { + "bbox": [ + 186, + 178, + 424, + 195 + ], + "score": 0.9, + "content": "\\nabla J ( \\theta ) = \\mathbb { E } _ { T \\sim \\mathcal { P } ( \\mathcal { T } ) } \\nabla \\widetilde { f } ^ { T } ( \\theta + \\alpha \\nabla \\widetilde { f } ^ { T } ( \\theta ) ) ( \\mathbf { I } + \\alpha \\nabla ^ { 2 } \\widetilde { f } ^ { T } ( \\theta ) ) .", + "type": "interline_equation", + "image_path": "651d787182521ed9ad2d9eb72c2b88016d2adaa520df98ff45a5244f11921f0c.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 186, + 178, + 424, + 195 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 197, + 506, + 231 + ], + "lines": [ + { + "bbox": [ + 105, + 196, + 506, + 210 + ], + "spans": [ + { + "bbox": [ + 105, + 196, + 506, + 210 + ], + "score": 1.0, + "content": "This is analogous to formulas obtained in e.g (Liu et al., 2019) for the policy gradient MAML. We", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 209, + 505, + 221 + ], + "spans": [ + { + "bbox": [ + 106, + 209, + 505, + 221 + ], + "score": 1.0, + "content": "can then approximate this gradient as an input to stochastic first-order methods. An example with", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 220, + 267, + 231 + ], + "spans": [ + { + "bbox": [ + 106, + 220, + 267, + 231 + ], + "score": 1.0, + "content": "standard SGD is shown in Algorithm 5.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 196, + 506, + 231 + ] + }, + { + "type": "index", + "bbox": [ + 299, + 238, + 492, + 388 + ], + "lines": [ + { + "bbox": [ + 308, + 237, + 491, + 251 + ], + "spans": [ + { + "bbox": [ + 308, + 237, + 388, + 251 + ], + "score": 1.0, + "content": "Data: initial policy", + "type": "text" + }, + { + "bbox": [ + 388, + 239, + 398, + 250 + ], + "score": 0.88, + "content": "\\theta _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 237, + 483, + 251 + ], + "score": 1.0, + "content": ", adaptation step size", + "type": "text" + }, + { + "bbox": [ + 483, + 241, + 491, + 248 + ], + "score": 0.77, + "content": "\\alpha", + "type": "inline_equation" + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 334, + 249, + 491, + 261 + ], + "spans": [ + { + "bbox": [ + 334, + 249, + 393, + 261 + ], + "score": 1.0, + "content": "meta step size", + "type": "text" + }, + { + "bbox": [ + 394, + 250, + 401, + 261 + ], + "score": 0.83, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 249, + 480, + 261 + ], + "score": 1.0, + "content": ", number of queries", + "type": "text" + }, + { + "bbox": [ + 480, + 250, + 491, + 259 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 300, + 260, + 387, + 272 + ], + "spans": [ + { + "bbox": [ + 300, + 260, + 323, + 272 + ], + "score": 1.0, + "content": "1 for", + "type": "text" + }, + { + "bbox": [ + 324, + 261, + 379, + 272 + ], + "score": 0.59, + "content": "t = 0 , 1 , \\ldots { } \\mathbf { d }", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 260, + 387, + 272 + ], + "score": 1.0, + "content": "o", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 300, + 269, + 437, + 285 + ], + "spans": [ + { + "bbox": [ + 300, + 274, + 306, + 281 + ], + "score": 1.0, + "content": "2", + "type": "text" + }, + { + "bbox": [ + 321, + 269, + 356, + 285 + ], + "score": 1.0, + "content": "Sample", + "type": "text" + }, + { + "bbox": [ + 356, + 273, + 364, + 281 + ], + "score": 0.77, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 269, + 387, + 285 + ], + "score": 1.0, + "content": "tasks", + "type": "text" + }, + { + "bbox": [ + 387, + 271, + 432, + 282 + ], + "score": 0.91, + "content": "T _ { 1 } , \\ldots , T _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 269, + 437, + 285 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 300, + 281, + 384, + 294 + ], + "spans": [ + { + "bbox": [ + 300, + 285, + 306, + 294 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 323, + 281, + 357, + 294 + ], + "score": 1.0, + "content": "foreach", + "type": "text" + }, + { + "bbox": [ + 358, + 283, + 368, + 293 + ], + "score": 0.82, + "content": "T _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 281, + 384, + 294 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 300, + 291, + 474, + 310 + ], + "spans": [ + { + "bbox": [ + 300, + 299, + 307, + 308 + ], + "score": 1.0, + "content": "4", + "type": "text" + }, + { + "bbox": [ + 338, + 294, + 469, + 308 + ], + "score": 0.64, + "content": "\\mathbf { d } _ { 1 } ^ { ( i ) } \\mathrm { E S G R A D } ( f ^ { T _ { i } } , \\theta _ { t } , K , \\sigma )", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 291, + 474, + 310 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 300, + 309, + 469, + 321 + ], + "spans": [ + { + "bbox": [ + 300, + 311, + 307, + 321 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 338, + 309, + 469, + 321 + ], + "score": 0.52, + "content": "\\mathbf { H } ^ { ( i ) } \\gets \\mathrm { E S H E S S } ( f ^ { T _ { i } } , \\theta _ { t } , K , \\sigma ) ;", + "type": "inline_equation" + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 300, + 319, + 419, + 338 + ], + "spans": [ + { + "bbox": [ + 300, + 326, + 307, + 335 + ], + "score": 1.0, + "content": "6", + "type": "text" + }, + { + "bbox": [ + 339, + 322, + 414, + 335 + ], + "score": 0.51, + "content": "\\boldsymbol { \\theta } _ { t } ^ { ( i ) } \\boldsymbol { \\theta } _ { t } + \\alpha \\cdot \\mathbf { d } _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 319, + 419, + 338 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 299, + 332, + 481, + 353 + ], + "spans": [ + { + "bbox": [ + 299, + 341, + 307, + 350 + ], + "score": 1.0, + "content": "7", + "type": "text" + }, + { + "bbox": [ + 338, + 336, + 476, + 351 + ], + "score": 0.47, + "content": "\\mathbf { d } _ { 2 } ^ { ( i ) } \\gets \\mathrm { E S G R A D } ( f ^ { T _ { i } } , \\theta _ { t } ^ { ( i ) } , K , \\sigma ) ;", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 332, + 481, + 353 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 299, + 349, + 343, + 362 + ], + "spans": [ + { + "bbox": [ + 299, + 352, + 307, + 362 + ], + "score": 1.0, + "content": "8", + "type": "text" + }, + { + "bbox": [ + 322, + 349, + 343, + 362 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 299, + 362, + 478, + 379 + ], + "spans": [ + { + "bbox": [ + 299, + 367, + 307, + 376 + ], + "score": 1.0, + "content": "9", + "type": "text" + }, + { + "bbox": [ + 324, + 362, + 478, + 379 + ], + "score": 0.55, + "content": "\\begin{array} { r } { \\theta _ { t + 1 } \\theta _ { t } + \\frac { \\beta } { n } \\sum _ { i = 1 } ^ { n } ( \\mathbf { I } + \\alpha \\mathbf { H } ^ { ( i ) } ) \\mathbf { d } _ { 2 } ^ { ( i ) } ; } \\end{array}", + "type": "inline_equation" + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 295, + 377, + 327, + 389 + ], + "spans": [ + { + "bbox": [ + 295, + 377, + 327, + 389 + ], + "score": 1.0, + "content": "10 end", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + } + ], + "index": 18.5, + "bbox_fs": [ + 295, + 237, + 491, + 389 + ] + }, + { + "type": "list", + "bbox": [ + 97, + 272, + 285, + 367 + ], + "lines": [ + { + "bbox": [ + 97, + 271, + 186, + 286 + ], + "spans": [ + { + "bbox": [ + 97, + 271, + 141, + 286 + ], + "score": 1.0, + "content": "1 ESHess", + "type": "text" + }, + { + "bbox": [ + 142, + 273, + 186, + 285 + ], + "score": 0.9, + "content": "( f , \\theta , n , \\sigma )", + "type": "inline_equation" + } + ], + "index": 13, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 120, + 282, + 282, + 295 + ], + "spans": [ + { + "bbox": [ + 120, + 282, + 190, + 295 + ], + "score": 1.0, + "content": "inputs: function", + "type": "text" + }, + { + "bbox": [ + 190, + 284, + 197, + 295 + ], + "score": 0.84, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 282, + 228, + 295 + ], + "score": 1.0, + "content": ", policy", + "type": "text" + }, + { + "bbox": [ + 228, + 284, + 234, + 293 + ], + "score": 0.79, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 282, + 282, + 295 + ], + "score": 1.0, + "content": ", number of", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 152, + 294, + 267, + 306 + ], + "spans": [ + { + "bbox": [ + 152, + 294, + 209, + 306 + ], + "score": 1.0, + "content": "perturbations", + "type": "text" + }, + { + "bbox": [ + 209, + 297, + 216, + 304 + ], + "score": 0.75, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 294, + 259, + 306 + ], + "score": 1.0, + "content": ", precision", + "type": "text" + }, + { + "bbox": [ + 259, + 297, + 267, + 304 + ], + "score": 0.73, + "content": "\\sigma", + "type": "inline_equation" + } + ], + "index": 15, + "is_list_end_line": true + }, + { + "bbox": [ + 97, + 303, + 286, + 336 + ], + "spans": [ + { + "bbox": [ + 97, + 308, + 105, + 329 + ], + "score": 1.0, + "content": "2 3", + "type": "text" + }, + { + "bbox": [ + 122, + 316, + 224, + 330 + ], + "score": 0.85, + "content": "\\textstyle v \\gets { \\frac { 1 } { n } } \\sum _ { i = 1 } ^ { n } f ( \\theta + \\sigma \\mathbf { g } _ { i } )", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 305, + 204, + 317 + ], + "score": 0.93, + "content": "\\mathcal { N } ( 0 , \\bf { I } )", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 303, + 237, + 336 + ], + "score": 1.0, + "content": "ors ;", + "type": "text" + }, + { + "bbox": [ + 237, + 307, + 281, + 317 + ], + "score": 0.88, + "content": "\\mathbf { g } _ { 1 } , \\ldots , \\mathbf { g } _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 282, + 303, + 286, + 336 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 98, + 324, + 262, + 348 + ], + "spans": [ + { + "bbox": [ + 98, + 334, + 104, + 341 + ], + "score": 1.0, + "content": "4", + "type": "text" + }, + { + "bbox": [ + 122, + 330, + 254, + 343 + ], + "score": 0.87, + "content": "\\begin{array} { r } { \\mathbf { H } ^ { 0 } \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } f ( \\theta + \\sigma \\mathbf { g } _ { i } ) \\mathbf { g } _ { i } \\mathbf { g } _ { i } ^ { T } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 324, + 262, + 348 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 21, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 98, + 342, + 219, + 357 + ], + "spans": [ + { + "bbox": [ + 98, + 347, + 104, + 354 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 119, + 342, + 152, + 357 + ], + "score": 1.0, + "content": "return", + "type": "text" + }, + { + "bbox": [ + 152, + 343, + 214, + 356 + ], + "score": 0.89, + "content": "\\begin{array} { r } { \\frac { 1 } { \\sigma ^ { 2 } } ( \\mathbf { H } ^ { 0 } - v \\cdot \\mathbf { I } ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 342, + 219, + 357 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 22, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 126, + 354, + 286, + 366 + ], + "spans": [ + { + "bbox": [ + 126, + 354, + 286, + 366 + ], + "score": 1.0, + "content": "Algorithm 4: Monte Carlo ES Hessian", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20, + "bbox_fs": [ + 97, + 271, + 286, + 366 + ] + }, + { + "type": "text", + "bbox": [ + 331, + 389, + 482, + 400 + ], + "lines": [ + { + "bbox": [ + 331, + 388, + 482, + 401 + ], + "spans": [ + { + "bbox": [ + 331, + 388, + 482, + 401 + ], + "score": 1.0, + "content": "Algorithm 5: First Order ES-MAML", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29, + "bbox_fs": [ + 331, + 388, + 482, + 401 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 406, + 506, + 432 + ], + "lines": [ + { + "bbox": [ + 106, + 406, + 506, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 406, + 506, + 420 + ], + "score": 1.0, + "content": "A central problem, as discussed in (Rothfuss et al., 2019; Liu et al., 2019) is the estimation of", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 417, + 506, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 418, + 145, + 432 + ], + "score": 0.92, + "content": "\\nabla ^ { 2 } \\widetilde { f } ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 417, + 506, + 435 + ], + "score": 1.0, + "content": ". However, a simple expression exists for this object in the ES setting; it can be shown that", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5, + "bbox_fs": [ + 106, + 406, + 506, + 435 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 188, + 434, + 423, + 458 + ], + "lines": [ + { + "bbox": [ + 188, + 434, + 423, + 458 + ], + "spans": [ + { + "bbox": [ + 188, + 434, + 423, + 458 + ], + "score": 0.93, + "content": "\\nabla ^ { 2 } \\widetilde { f } ^ { T } ( \\theta ) = \\frac { 1 } { \\sigma ^ { 2 } } ( \\mathbb { E } _ { \\mathbf { h } \\sim \\mathcal { N } ( 0 , \\mathbf { I } ) } [ f ^ { T } ( \\theta + \\sigma \\mathbf { h } ) \\mathbf { h } \\mathbf { h } ^ { T } ] - \\widetilde { f } ^ { T } ( \\theta ) \\mathbf { I } ] .", + "type": "interline_equation", + "image_path": "2b139dbfffb12608adb955bc82ca40935c271d49f8fdf2a722cb5c9ad7ae0a2a.jpg" + } + ] + } + ], + "index": 32, + "virtual_lines": [ + { + "bbox": [ + 188, + 434, + 423, + 458 + ], + "spans": [], + "index": 32 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 461, + 505, + 497 + ], + "lines": [ + { + "bbox": [ + 105, + 460, + 506, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 203, + 474 + ], + "score": 1.0, + "content": "Note that for the vector", + "type": "text" + }, + { + "bbox": [ + 203, + 462, + 210, + 472 + ], + "score": 0.36, + "content": "\\mathbf { h }", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 460, + 214, + 474 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 214, + 461, + 228, + 473 + ], + "score": 0.84, + "content": "\\mathbf { h } ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 460, + 388, + 474 + ], + "score": 1.0, + "content": "is the transpose (and unrelated to tasks", + "type": "text" + }, + { + "bbox": [ + 388, + 462, + 397, + 472 + ], + "score": 0.76, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 460, + 506, + 474 + ], + "score": 1.0, + "content": "). A basic MC estimator is", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 473, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 344, + 487 + ], + "score": 1.0, + "content": "shown in Algorithm 4. Given an independent estimator for", + "type": "text" + }, + { + "bbox": [ + 345, + 473, + 431, + 487 + ], + "score": 0.94, + "content": "\\nabla \\widetilde { f } ^ { T } ( \\theta + \\alpha \\nabla \\widetilde { f } ^ { T } ( \\theta ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 431, + 474, + 505, + 487 + ], + "score": 1.0, + "content": ", we can then take", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 486, + 277, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 257, + 497 + ], + "score": 1.0, + "content": "the product to obtain an estimator for", + "type": "text" + }, + { + "bbox": [ + 258, + 486, + 273, + 496 + ], + "score": 0.83, + "content": "\\nabla J", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 486, + 277, + 497 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34, + "bbox_fs": [ + 105, + 460, + 506, + 497 + ] + }, + { + "type": "title", + "bbox": [ + 106, + 510, + 343, + 522 + ], + "lines": [ + { + "bbox": [ + 106, + 510, + 344, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 510, + 344, + 523 + ], + "score": 1.0, + "content": "A.1.2 EXPERIMENTS WITH FIRST-ORDER ES-MAML", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 36 + }, + { + "type": "text", + "bbox": [ + 107, + 530, + 505, + 578 + ], + "lines": [ + { + "bbox": [ + 105, + 530, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 505, + 543 + ], + "score": 1.0, + "content": "Unlike zero-order ES-MAML (Algorithm 3), the first-order ES-MAML explicitly builds an approx-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 541, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 214, + 554 + ], + "score": 1.0, + "content": "imation of the Hessian of", + "type": "text" + }, + { + "bbox": [ + 214, + 541, + 227, + 554 + ], + "score": 0.9, + "content": "f ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 541, + 505, + 554 + ], + "score": 1.0, + "content": ". Given the literature on PG-MAML, we expect that estimating the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 553, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 553, + 140, + 568 + ], + "score": 1.0, + "content": "Hessian", + "type": "text" + }, + { + "bbox": [ + 141, + 553, + 179, + 567 + ], + "score": 0.93, + "content": "\\nabla ^ { 2 } \\widetilde { f } ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 180, + 553, + 505, + 568 + ], + "score": 1.0, + "content": "with Algorithm 4 without any control variates may have high variance. We com-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 566, + 282, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 282, + 578 + ], + "score": 1.0, + "content": "pare two variants of first-order ES-MAML:", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38.5, + "bbox_fs": [ + 105, + 530, + 505, + 578 + ] + }, + { + "type": "list", + "bbox": [ + 128, + 585, + 505, + 641 + ], + "lines": [ + { + "bbox": [ + 130, + 585, + 367, + 598 + ], + "spans": [ + { + "bbox": [ + 130, + 585, + 367, + 598 + ], + "score": 1.0, + "content": "1. The full version (FO-Hessian) specified in Algorithm 5.", + "type": "text" + } + ], + "index": 41, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 128, + 600, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 128, + 601, + 429, + 614 + ], + "score": 1.0, + "content": "2. The ‘first-order approximation’ (FO-NoHessian) which ignores the term", + "type": "text" + }, + { + "bbox": [ + 429, + 600, + 487, + 614 + ], + "score": 0.94, + "content": "\\mathbf { I } + \\alpha \\nabla ^ { 2 } \\widetilde { f } ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 601, + 506, + 614 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 613, + 506, + 629 + ], + "spans": [ + { + "bbox": [ + 141, + 615, + 293, + 628 + ], + "score": 1.0, + "content": "approximates the MAML gradient as", + "type": "text" + }, + { + "bbox": [ + 293, + 613, + 417, + 629 + ], + "score": 0.94, + "content": "\\mathbb { E } _ { T \\sim \\mathcal { P } ( \\mathcal { T } ) } \\nabla \\widetilde { f } ^ { T } ( \\theta + \\alpha \\nabla \\widetilde { f } ^ { T } ( \\theta ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 418, + 615, + 506, + 628 + ], + "score": 1.0, + "content": ". This is equivalent to", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 141, + 627, + 311, + 641 + ], + "spans": [ + { + "bbox": [ + 141, + 628, + 171, + 641 + ], + "score": 1.0, + "content": "setting", + "type": "text" + }, + { + "bbox": [ + 172, + 627, + 209, + 639 + ], + "score": 0.91, + "content": "\\mathbf { H } ^ { ( i ) } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 628, + 311, + 641 + ], + "score": 1.0, + "content": "in line 5 of Algorithm 5.", + "type": "text" + } + ], + "index": 44, + "is_list_end_line": true + } + ], + "index": 42.5, + "bbox_fs": [ + 128, + 585, + 506, + 641 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 648, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 106, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "The results on the four corner exploration problem (Section 4.1) and the Forward-Backward Ant,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 659, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 505, + 673 + ], + "score": 1.0, + "content": "using Linear policies, are shown in Figure A1. On Forward-Backward Ant, FO-NoHessian actually", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "score": 1.0, + "content": "outperformed FO-Hessian, so the inclusion of the Hessian term actually slowed convergence. On", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 680, + 505, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 505, + 695 + ], + "score": 1.0, + "content": "the four corners task, both FO-Hessian and FO-NoHessian have large error bars, and FO-Hessian", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 693, + 254, + 705 + ], + "spans": [ + { + "bbox": [ + 106, + 693, + 254, + 705 + ], + "score": 1.0, + "content": "slightly outperforms FO-NoHessian.", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 47, + "bbox_fs": [ + 105, + 649, + 505, + 705 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "There is conflicting evidence as to whether the same phenomenon occurs with PG-MAML; (Finn", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 720, + 504, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 504, + 732 + ], + "score": 1.0, + "content": "et al., 2017, §5.2) found that on supervised learning MAML, omitting Hessian terms is competitive", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 250, + 506, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 506, + 263 + ], + "score": 1.0, + "content": "but slightly worse than the full PG-MAML, and does not report comparisons with and without the", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 261, + 505, + 274 + ], + "spans": [ + { + "bbox": [ + 105, + 261, + 505, + 274 + ], + "score": 1.0, + "content": "Hessian on RL MAML. (Rothfuss et al., 2019; Liu et al., 2019) argue for the importance of the", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 273, + 505, + 285 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 505, + 285 + ], + "score": 1.0, + "content": "second-order terms in proper credit assignment, but use heavily modified estimators (LVC, control", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 284, + 505, + 296 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 505, + 296 + ], + "score": 1.0, + "content": "variates; see Section 2) in their experiments, so the performance is not directly comparable to the", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 293, + 506, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 506, + 308 + ], + "score": 1.0, + "content": "‘naive’ estimator in Algorithm 4. Our interpretation is that Algorithm 4 has high variance, making", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 306, + 505, + 318 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 505, + 318 + ], + "score": 1.0, + "content": "the Hessian estimates inaccurate, which can slow training on relatively ‘easier’ tasks like Forward-", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 317, + 397, + 328 + ], + "spans": [ + { + "bbox": [ + 106, + 317, + 397, + 328 + ], + "score": 1.0, + "content": "Backward walking but possibly increase the exploration on four corners.", + "type": "text", + "cross_page": true + } + ], + "index": 10 + } + ], + "index": 50.5, + "bbox_fs": [ + 105, + 709, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 125, + 103, + 484, + 229 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 115, + 89, + 494, + 100 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 114, + 88, + 496, + 103 + ], + "spans": [ + { + "bbox": [ + 114, + 88, + 496, + 103 + ], + "score": 1.0, + "content": "Figure A1: Comparisons between the FO-Hessian and FO-NoHessian variants of Algorithm 5.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "image_body", + "bbox": [ + 125, + 103, + 484, + 229 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 125, + 103, + 484, + 229 + ], + "spans": [ + { + "bbox": [ + 125, + 103, + 484, + 229 + ], + "score": 0.965, + "type": "image", + "image_path": "b82fcd95dae65f3632d4d9f37f08172486d0d7d9b5f324ebb484980053c65788.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 125, + 103, + 484, + 145.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 125, + 145.0, + 484, + 187.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 125, + 187.0, + 484, + 229.0 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "text", + "bbox": [ + 106, + 250, + 505, + 328 + ], + "lines": [ + { + "bbox": [ + 105, + 250, + 506, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 506, + 263 + ], + "score": 1.0, + "content": "but slightly worse than the full PG-MAML, and does not report comparisons with and without the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 261, + 505, + 274 + ], + "spans": [ + { + "bbox": [ + 105, + 261, + 505, + 274 + ], + "score": 1.0, + "content": "Hessian on RL MAML. (Rothfuss et al., 2019; Liu et al., 2019) argue for the importance of the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 273, + 505, + 285 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 505, + 285 + ], + "score": 1.0, + "content": "second-order terms in proper credit assignment, but use heavily modified estimators (LVC, control", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 284, + 505, + 296 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 505, + 296 + ], + "score": 1.0, + "content": "variates; see Section 2) in their experiments, so the performance is not directly comparable to the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 293, + 506, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 506, + 308 + ], + "score": 1.0, + "content": "‘naive’ estimator in Algorithm 4. Our interpretation is that Algorithm 4 has high variance, making", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 306, + 505, + 318 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 505, + 318 + ], + "score": 1.0, + "content": "the Hessian estimates inaccurate, which can slow training on relatively ‘easier’ tasks like Forward-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 317, + 397, + 328 + ], + "spans": [ + { + "bbox": [ + 106, + 317, + 397, + 328 + ], + "score": 1.0, + "content": "Backward walking but possibly increase the exploration on four corners.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 106, + 333, + 505, + 399 + ], + "lines": [ + { + "bbox": [ + 106, + 334, + 505, + 345 + ], + "spans": [ + { + "bbox": [ + 106, + 334, + 505, + 345 + ], + "score": 1.0, + "content": "We also compare FO-NoHessian against Algorithm 3 on Forward-Backward HalfCheetah and Ant", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 344, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 505, + 357 + ], + "score": 1.0, + "content": "in Figure A2. In this experiment, the two methods ran on servers with different number of workers", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 355, + 506, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 355, + 506, + 367 + ], + "score": 1.0, + "content": "available, so we measure the score by the total number of rollouts. We found that FO-NoHessian", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 366, + 505, + 378 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 505, + 378 + ], + "score": 1.0, + "content": "was slightly faster than Algorithm 3 when measured by rollouts on Ant, but FO-NoHessian had", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 378, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 362, + 389 + ], + "score": 1.0, + "content": "notably poor performance when the number of queries was low", + "type": "text" + }, + { + "bbox": [ + 363, + 378, + 392, + 388 + ], + "score": 0.87, + "content": "K = 5", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 378, + 505, + 389 + ], + "score": 1.0, + "content": ") on HalfCheetah, and failed", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 389, + 423, + 400 + ], + "spans": [ + { + "bbox": [ + 106, + 389, + 423, + 400 + ], + "score": 1.0, + "content": "to reach similar scores as the others even after running for many more rollouts.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13.5 + }, + { + "type": "image", + "bbox": [ + 129, + 433, + 486, + 565 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 149, + 419, + 463, + 431 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 147, + 417, + 464, + 433 + ], + "spans": [ + { + "bbox": [ + 147, + 417, + 464, + 433 + ], + "score": 1.0, + "content": "Figure A2: Comparisons between FO-NoHessian and Algorithm 3, by rollouts", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "image_body", + "bbox": [ + 129, + 433, + 486, + 565 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 129, + 433, + 486, + 565 + ], + "spans": [ + { + "bbox": [ + 129, + 433, + 486, + 565 + ], + "score": 0.962, + "type": "image", + "image_path": "a058edbaf35f35e07ea9570ef2c283ac43bc722a77d3a7e8914bfdd7ff486d46.jpg" + } + ] + } + ], + "index": 19, + "virtual_lines": [ + { + "bbox": [ + 129, + 433, + 486, + 477.0 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 129, + 477.0, + 486, + 521.0 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 129, + 521.0, + 486, + 565.0 + ], + "spans": [], + "index": 20 + } + ] + } + ], + "index": 18.0 + }, + { + "type": "title", + "bbox": [ + 108, + 587, + 288, + 600 + ], + "lines": [ + { + "bbox": [ + 106, + 586, + 289, + 602 + ], + "spans": [ + { + "bbox": [ + 106, + 586, + 289, + 602 + ], + "score": 1.0, + "content": "A.2 HANDLING ESTIMATOR BIAS", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 108, + 612, + 505, + 635 + ], + "lines": [ + { + "bbox": [ + 105, + 611, + 505, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 210, + 625 + ], + "score": 1.0, + "content": "Since the adapted policy", + "type": "text" + }, + { + "bbox": [ + 211, + 612, + 244, + 623 + ], + "score": 0.89, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 244, + 611, + 505, + 625 + ], + "score": 1.0, + "content": "generally cannot be evaluated exactly, we cannot easily obtain", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 622, + 486, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 195, + 636 + ], + "score": 1.0, + "content": "unbiased estimates of", + "type": "text" + }, + { + "bbox": [ + 195, + 623, + 248, + 635 + ], + "score": 0.92, + "content": "f ^ { T } ( U ( \\theta , T ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 622, + 486, + 636 + ], + "score": 1.0, + "content": ". This problem arises for both PG-MAML and ES-MAML.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 106, + 640, + 505, + 674 + ], + "lines": [ + { + "bbox": [ + 105, + 638, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 459, + 653 + ], + "score": 1.0, + "content": "We consider PG-MAML first as an example. In PG-MAML, the adaptation operator is", + "type": "text" + }, + { + "bbox": [ + 460, + 640, + 505, + 652 + ], + "score": 0.89, + "content": "U ( \\theta , T ) =", + "type": "inline_equation" + } + ], + "index": 24 + }, + { + "bbox": [ + 107, + 650, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 107, + 651, + 215, + 664 + ], + "score": 0.91, + "content": "\\theta + \\alpha \\nabla _ { \\theta } \\mathbb { E } _ { \\tau \\sim \\mathcal { P } _ { T } ( \\tau \\mid \\theta ) } [ R ( \\tau ) ]", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 650, + 400, + 664 + ], + "score": 1.0, + "content": ". In general, we can only obtain an estimate of", + "type": "text" + }, + { + "bbox": [ + 401, + 651, + 487, + 664 + ], + "score": 0.93, + "content": "\\nabla _ { \\boldsymbol { \\theta } } \\mathbb { E } _ { \\tau \\sim \\mathcal { P } _ { T } ( \\tau \\mid \\boldsymbol { \\theta } ) } [ R ( \\tau ) ]", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 650, + 506, + 664 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 661, + 354, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 661, + 354, + 676 + ], + "score": 1.0, + "content": "not its exact value. However, the MAML gradient is given by", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25 + }, + { + "type": "interline_equation", + "bbox": [ + 159, + 678, + 452, + 693 + ], + "lines": [ + { + "bbox": [ + 159, + 678, + 452, + 693 + ], + "spans": [ + { + "bbox": [ + 159, + 678, + 452, + 693 + ], + "score": 0.9, + "content": "\\nabla _ { \\theta } J ( \\theta ) = \\mathbb { E } _ { \\mathcal { T } \\sim \\mathcal { P } ( \\mathcal { T } ) } [ \\mathbb { E } _ { r ^ { \\prime } \\sim \\mathcal { P } _ { \\mathcal { T } } ( \\tau ^ { \\prime } \\mid \\theta ^ { \\prime } ) } [ \\nabla _ { \\theta ^ { \\prime } } \\log \\mathcal { P } _ { \\mathcal { T } } ( \\tau ^ { \\prime } \\mid \\theta ^ { \\prime } ) R ( \\tau ^ { \\prime } ) \\nabla _ { \\theta } U ( \\theta , T ) ] ]", + "type": "interline_equation", + "image_path": "5ef726f30396343a1b8ccbc721c97fba5ab1acf4b9e487bd0afecda319d32c46.jpg" + } + ] + } + ], + "index": 27, + "virtual_lines": [ + { + "bbox": [ + 159, + 678, + 452, + 693 + ], + "spans": [], + "index": 27 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 698, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 354, + 712 + ], + "score": 1.0, + "content": "which requires exact sampling from the adapted trajectories", + "type": "text" + }, + { + "bbox": [ + 355, + 698, + 445, + 711 + ], + "score": 0.91, + "content": "\\tau ^ { \\prime } \\sim \\mathcal { P } _ { T } ( \\tau ^ { \\prime } | U ( \\theta , T ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 445, + 698, + 506, + 712 + ], + "score": 1.0, + "content": ". Since this is", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 104, + 709, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 104, + 709, + 205, + 722 + ], + "score": 1.0, + "content": "a nonlinear function of", + "type": "text" + }, + { + "bbox": [ + 205, + 710, + 237, + 721 + ], + "score": 0.91, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 238, + 709, + 409, + 722 + ], + "score": 1.0, + "content": ", we cannot obtain unbiased estimates of", + "type": "text" + }, + { + "bbox": [ + 410, + 710, + 438, + 722 + ], + "score": 0.89, + "content": "\\nabla J ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 709, + 494, + 722 + ], + "score": 1.0, + "content": "by sampling", + "type": "text" + }, + { + "bbox": [ + 495, + 711, + 504, + 720 + ], + "score": 0.84, + "content": "\\tau ^ { \\prime }", + "type": "inline_equation" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 720, + 257, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 219, + 733 + ], + "score": 1.0, + "content": "generated by an estimate of", + "type": "text" + }, + { + "bbox": [ + 219, + 722, + 252, + 732 + ], + "score": 0.93, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 720, + 257, + 733 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29 + } + ], + "page_idx": 12, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "13", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 125, + 103, + 484, + 229 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 115, + 89, + 494, + 100 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 114, + 88, + 496, + 103 + ], + "spans": [ + { + "bbox": [ + 114, + 88, + 496, + 103 + ], + "score": 1.0, + "content": "Figure A1: Comparisons between the FO-Hessian and FO-NoHessian variants of Algorithm 5.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "image_body", + "bbox": [ + 125, + 103, + 484, + 229 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 125, + 103, + 484, + 229 + ], + "spans": [ + { + "bbox": [ + 125, + 103, + 484, + 229 + ], + "score": 0.965, + "type": "image", + "image_path": "b82fcd95dae65f3632d4d9f37f08172486d0d7d9b5f324ebb484980053c65788.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 125, + 103, + 484, + 145.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 125, + 145.0, + 484, + 187.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 125, + 187.0, + 484, + 229.0 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "text", + "bbox": [ + 106, + 250, + 505, + 328 + ], + "lines": [], + "index": 7, + "bbox_fs": [ + 105, + 250, + 506, + 328 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 333, + 505, + 399 + ], + "lines": [ + { + "bbox": [ + 106, + 334, + 505, + 345 + ], + "spans": [ + { + "bbox": [ + 106, + 334, + 505, + 345 + ], + "score": 1.0, + "content": "We also compare FO-NoHessian against Algorithm 3 on Forward-Backward HalfCheetah and Ant", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 344, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 505, + 357 + ], + "score": 1.0, + "content": "in Figure A2. In this experiment, the two methods ran on servers with different number of workers", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 355, + 506, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 355, + 506, + 367 + ], + "score": 1.0, + "content": "available, so we measure the score by the total number of rollouts. We found that FO-NoHessian", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 366, + 505, + 378 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 505, + 378 + ], + "score": 1.0, + "content": "was slightly faster than Algorithm 3 when measured by rollouts on Ant, but FO-NoHessian had", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 378, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 362, + 389 + ], + "score": 1.0, + "content": "notably poor performance when the number of queries was low", + "type": "text" + }, + { + "bbox": [ + 363, + 378, + 392, + 388 + ], + "score": 0.87, + "content": "K = 5", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 378, + 505, + 389 + ], + "score": 1.0, + "content": ") on HalfCheetah, and failed", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 389, + 423, + 400 + ], + "spans": [ + { + "bbox": [ + 106, + 389, + 423, + 400 + ], + "score": 1.0, + "content": "to reach similar scores as the others even after running for many more rollouts.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13.5, + "bbox_fs": [ + 105, + 334, + 506, + 400 + ] + }, + { + "type": "image", + "bbox": [ + 129, + 433, + 486, + 565 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 149, + 419, + 463, + 431 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 147, + 417, + 464, + 433 + ], + "spans": [ + { + "bbox": [ + 147, + 417, + 464, + 433 + ], + "score": 1.0, + "content": "Figure A2: Comparisons between FO-NoHessian and Algorithm 3, by rollouts", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "image_body", + "bbox": [ + 129, + 433, + 486, + 565 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 129, + 433, + 486, + 565 + ], + "spans": [ + { + "bbox": [ + 129, + 433, + 486, + 565 + ], + "score": 0.962, + "type": "image", + "image_path": "a058edbaf35f35e07ea9570ef2c283ac43bc722a77d3a7e8914bfdd7ff486d46.jpg" + } + ] + } + ], + "index": 19, + "virtual_lines": [ + { + "bbox": [ + 129, + 433, + 486, + 477.0 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 129, + 477.0, + 486, + 521.0 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 129, + 521.0, + 486, + 565.0 + ], + "spans": [], + "index": 20 + } + ] + } + ], + "index": 18.0 + }, + { + "type": "title", + "bbox": [ + 108, + 587, + 288, + 600 + ], + "lines": [ + { + "bbox": [ + 106, + 586, + 289, + 602 + ], + "spans": [ + { + "bbox": [ + 106, + 586, + 289, + 602 + ], + "score": 1.0, + "content": "A.2 HANDLING ESTIMATOR BIAS", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 108, + 612, + 505, + 635 + ], + "lines": [ + { + "bbox": [ + 105, + 611, + 505, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 210, + 625 + ], + "score": 1.0, + "content": "Since the adapted policy", + "type": "text" + }, + { + "bbox": [ + 211, + 612, + 244, + 623 + ], + "score": 0.89, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 244, + 611, + 505, + 625 + ], + "score": 1.0, + "content": "generally cannot be evaluated exactly, we cannot easily obtain", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 622, + 486, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 195, + 636 + ], + "score": 1.0, + "content": "unbiased estimates of", + "type": "text" + }, + { + "bbox": [ + 195, + 623, + 248, + 635 + ], + "score": 0.92, + "content": "f ^ { T } ( U ( \\theta , T ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 622, + 486, + 636 + ], + "score": 1.0, + "content": ". This problem arises for both PG-MAML and ES-MAML.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 611, + 505, + 636 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 640, + 505, + 674 + ], + "lines": [ + { + "bbox": [ + 105, + 638, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 459, + 653 + ], + "score": 1.0, + "content": "We consider PG-MAML first as an example. In PG-MAML, the adaptation operator is", + "type": "text" + }, + { + "bbox": [ + 460, + 640, + 505, + 652 + ], + "score": 0.89, + "content": "U ( \\theta , T ) =", + "type": "inline_equation" + } + ], + "index": 24 + }, + { + "bbox": [ + 107, + 650, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 107, + 651, + 215, + 664 + ], + "score": 0.91, + "content": "\\theta + \\alpha \\nabla _ { \\theta } \\mathbb { E } _ { \\tau \\sim \\mathcal { P } _ { T } ( \\tau \\mid \\theta ) } [ R ( \\tau ) ]", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 650, + 400, + 664 + ], + "score": 1.0, + "content": ". In general, we can only obtain an estimate of", + "type": "text" + }, + { + "bbox": [ + 401, + 651, + 487, + 664 + ], + "score": 0.93, + "content": "\\nabla _ { \\boldsymbol { \\theta } } \\mathbb { E } _ { \\tau \\sim \\mathcal { P } _ { T } ( \\tau \\mid \\boldsymbol { \\theta } ) } [ R ( \\tau ) ]", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 650, + 506, + 664 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 661, + 354, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 661, + 354, + 676 + ], + "score": 1.0, + "content": "not its exact value. However, the MAML gradient is given by", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 638, + 506, + 676 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 159, + 678, + 452, + 693 + ], + "lines": [ + { + "bbox": [ + 159, + 678, + 452, + 693 + ], + "spans": [ + { + "bbox": [ + 159, + 678, + 452, + 693 + ], + "score": 0.9, + "content": "\\nabla _ { \\theta } J ( \\theta ) = \\mathbb { E } _ { \\mathcal { T } \\sim \\mathcal { P } ( \\mathcal { T } ) } [ \\mathbb { E } _ { r ^ { \\prime } \\sim \\mathcal { P } _ { \\mathcal { T } } ( \\tau ^ { \\prime } \\mid \\theta ^ { \\prime } ) } [ \\nabla _ { \\theta ^ { \\prime } } \\log \\mathcal { P } _ { \\mathcal { T } } ( \\tau ^ { \\prime } \\mid \\theta ^ { \\prime } ) R ( \\tau ^ { \\prime } ) \\nabla _ { \\theta } U ( \\theta , T ) ] ]", + "type": "interline_equation", + "image_path": "5ef726f30396343a1b8ccbc721c97fba5ab1acf4b9e487bd0afecda319d32c46.jpg" + } + ] + } + ], + "index": 27, + "virtual_lines": [ + { + "bbox": [ + 159, + 678, + 452, + 693 + ], + "spans": [], + "index": 27 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 698, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 354, + 712 + ], + "score": 1.0, + "content": "which requires exact sampling from the adapted trajectories", + "type": "text" + }, + { + "bbox": [ + 355, + 698, + 445, + 711 + ], + "score": 0.91, + "content": "\\tau ^ { \\prime } \\sim \\mathcal { P } _ { T } ( \\tau ^ { \\prime } | U ( \\theta , T ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 445, + 698, + 506, + 712 + ], + "score": 1.0, + "content": ". Since this is", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 104, + 709, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 104, + 709, + 205, + 722 + ], + "score": 1.0, + "content": "a nonlinear function of", + "type": "text" + }, + { + "bbox": [ + 205, + 710, + 237, + 721 + ], + "score": 0.91, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 238, + 709, + 409, + 722 + ], + "score": 1.0, + "content": ", we cannot obtain unbiased estimates of", + "type": "text" + }, + { + "bbox": [ + 410, + 710, + 438, + 722 + ], + "score": 0.89, + "content": "\\nabla J ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 709, + 494, + 722 + ], + "score": 1.0, + "content": "by sampling", + "type": "text" + }, + { + "bbox": [ + 495, + 711, + 504, + 720 + ], + "score": 0.84, + "content": "\\tau ^ { \\prime }", + "type": "inline_equation" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 720, + 257, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 219, + 733 + ], + "score": 1.0, + "content": "generated by an estimate of", + "type": "text" + }, + { + "bbox": [ + 219, + 722, + 252, + 732 + ], + "score": 0.93, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 720, + 257, + 733 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29, + "bbox_fs": [ + 104, + 698, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 81, + 505, + 118 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 316, + 95 + ], + "score": 1.0, + "content": "In the case of ES-MAML, the adaptation operator is", + "type": "text" + }, + { + "bbox": [ + 316, + 81, + 489, + 94 + ], + "score": 0.92, + "content": "U ( \\theta , T ) = \\theta + \\underline { { { \\alpha } } } \\nabla \\widetilde { f } ( \\theta , T ) = \\mathbb { E } _ { \\mathbf { h } } u ( \\theta , T ; \\mathbf { h } )", + "type": "inline_equation" + }, + { + "bbox": [ + 490, + 81, + 505, + 95 + ], + "score": 1.0, + "content": "for", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 92, + 506, + 108 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 160, + 106 + ], + "score": 0.92, + "content": "\\mathbf { h } \\sim { \\mathcal { N } } ( 0 , I )", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 92, + 191, + 108 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 191, + 93, + 328, + 106 + ], + "score": 0.92, + "content": "\\begin{array} { r } { u ( \\theta , T ; { \\bf h } ) = \\dot { \\theta } + \\frac { \\alpha } { \\sigma } f ^ { \\top } ( \\theta + \\sigma { \\bf h } ) { \\bf h } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 328, + 92, + 367, + 108 + ], + "score": 1.0, + "content": ". Clearly,", + "type": "text" + }, + { + "bbox": [ + 367, + 93, + 428, + 106 + ], + "score": 0.9, + "content": "f ^ { T } ( u ( \\theta , T ; \\mathbf { h } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 92, + 506, + 108 + ], + "score": 1.0, + "content": "is not an unbiased", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 215, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 157, + 119 + ], + "score": 1.0, + "content": "estimator of", + "type": "text" + }, + { + "bbox": [ + 157, + 105, + 210, + 119 + ], + "score": 0.93, + "content": "f ^ { \\mathcal { T } } ( U ( \\theta , T ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 104, + 215, + 119 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 106, + 122, + 505, + 189 + ], + "lines": [ + { + "bbox": [ + 105, + 122, + 506, + 136 + ], + "spans": [ + { + "bbox": [ + 105, + 122, + 347, + 136 + ], + "score": 1.0, + "content": "We may question whether using an unbiased estimator of", + "type": "text" + }, + { + "bbox": [ + 347, + 122, + 400, + 135 + ], + "score": 0.93, + "content": "f ^ { T } ( U ( \\theta , T ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 122, + 506, + 136 + ], + "score": 1.0, + "content": "is likely to improve per-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 135, + 505, + 146 + ], + "spans": [ + { + "bbox": [ + 106, + 135, + 505, + 146 + ], + "score": 1.0, + "content": "formance. One natural strategy is to reformulate the objective function so as to make the desired", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 145, + 505, + 158 + ], + "spans": [ + { + "bbox": [ + 106, + 145, + 505, + 158 + ], + "score": 1.0, + "content": "estimator unbiased. This happens to be the case for the algorithm E-MAML (Al-Shedivat et al.,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 156, + 505, + 169 + ], + "spans": [ + { + "bbox": [ + 106, + 156, + 391, + 169 + ], + "score": 1.0, + "content": "2018), which treats the adaptation operator as an explicit function of", + "type": "text" + }, + { + "bbox": [ + 392, + 156, + 402, + 166 + ], + "score": 0.82, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 156, + 505, + 169 + ], + "score": 1.0, + "content": "sampled trajectories and", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 166, + 506, + 181 + ], + "spans": [ + { + "bbox": [ + 105, + 166, + 420, + 181 + ], + "score": 1.0, + "content": "“moves the expectation outside”. That is, we now have an adaptation operator", + "type": "text" + }, + { + "bbox": [ + 421, + 167, + 501, + 179 + ], + "score": 0.92, + "content": "U ( \\theta , T ; \\tau _ { 1 } , \\dots , \\tau _ { K } )", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 166, + 506, + 181 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 177, + 250, + 191 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 250, + 191 + ], + "score": 1.0, + "content": "and the objective function becomes", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.5 + }, + { + "type": "interline_equation", + "bbox": [ + 210, + 194, + 401, + 210 + ], + "lines": [ + { + "bbox": [ + 210, + 194, + 401, + 210 + ], + "spans": [ + { + "bbox": [ + 210, + 194, + 401, + 210 + ], + "score": 0.92, + "content": "\\mathbb { E } _ { T } [ \\mathbb { E } _ { \\tau _ { 1 } , \\dots , \\tau _ { k } \\sim \\mathcal { P } _ { T } ( \\tau | \\theta ) } f ^ { T } ( U ( \\theta , T ; \\tau _ { 1 } , \\dots , \\tau _ { K } ) ) ]", + "type": "interline_equation", + "image_path": "5666b55ebe64c65d62012adf6908d58e87a6dece3107c4bf8b9dd33ddc11f47a.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 210, + 194, + 401, + 210 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 213, + 505, + 258 + ], + "lines": [ + { + "bbox": [ + 105, + 213, + 505, + 226 + ], + "spans": [ + { + "bbox": [ + 105, + 213, + 483, + 226 + ], + "score": 1.0, + "content": "An unbiased estimator for the E-MAML gradient can be obtained by sampling only from", + "type": "text" + }, + { + "bbox": [ + 484, + 216, + 505, + 224 + ], + "score": 0.81, + "content": "\\tau \\sim", + "type": "inline_equation" + } + ], + "index": 10 + }, + { + "bbox": [ + 107, + 225, + 505, + 237 + ], + "spans": [ + { + "bbox": [ + 107, + 225, + 142, + 237 + ], + "score": 0.92, + "content": "{ \\mathcal { P } } _ { T } ( \\tau | \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 225, + 505, + 237 + ], + "score": 1.0, + "content": "(Al-Shedivat et al., 2018). However, it has been argued that by doing so, E-MAML does", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 235, + 505, + 248 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 505, + 248 + ], + "score": 1.0, + "content": "not properly assign credit to the pre-adaptation policy (Rothfuss et al., 2019). Thus, this particular", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 247, + 345, + 258 + ], + "spans": [ + { + "bbox": [ + 105, + 247, + 345, + 258 + ], + "score": 1.0, + "content": "mathematical strategy seems to be disadvantageous for RL.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 106, + 263, + 505, + 341 + ], + "lines": [ + { + "bbox": [ + 106, + 263, + 505, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 263, + 358, + 276 + ], + "score": 1.0, + "content": "The problem of finding estimators for function-of-expectations", + "type": "text" + }, + { + "bbox": [ + 358, + 264, + 388, + 276 + ], + "score": 0.93, + "content": "f ( \\mathbb { E } X )", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 263, + 505, + 276 + ], + "score": 1.0, + "content": "is difficult and while general", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 275, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 106, + 275, + 505, + 286 + ], + "score": 1.0, + "content": "unbiased estimation methods exist (Blanchet et al., 2017), they are often complicated and suffer", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 285, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 106, + 285, + 505, + 298 + ], + "score": 1.0, + "content": "from high variance. In the context of MAML, ProMP compares the low variance curvature (LVC)", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 297, + 506, + 308 + ], + "spans": [ + { + "bbox": [ + 106, + 297, + 506, + 308 + ], + "score": 1.0, + "content": "estimator (Rothfuss et al., 2019), which is biased, against the unbiased DiCE estimator (Foerster", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 307, + 506, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 506, + 319 + ], + "score": 1.0, + "content": "et al., 2018), for the Hessian term in the MAML gradient, and found that the lower variance of LVC", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 318, + 506, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 506, + 331 + ], + "score": 1.0, + "content": "produced better performance than DiCE. Alternatively, control variates can be used to reduce the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 329, + 445, + 342 + ], + "spans": [ + { + "bbox": [ + 106, + 329, + 445, + 342 + ], + "score": 1.0, + "content": "variance of the DiCE estimator, which is the approach followed in (Liu et al., 2019).", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 106, + 345, + 505, + 393 + ], + "lines": [ + { + "bbox": [ + 105, + 345, + 506, + 359 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 452, + 359 + ], + "score": 1.0, + "content": "In the ES framework, the problem can also be formulated to avoid exactly evaluating", + "type": "text" + }, + { + "bbox": [ + 453, + 346, + 483, + 358 + ], + "score": 0.92, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 345, + 506, + 359 + ], + "score": 1.0, + "content": ", and", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 357, + 505, + 370 + ], + "spans": [ + { + "bbox": [ + 106, + 357, + 505, + 370 + ], + "score": 1.0, + "content": "hence circumvents the question of estimator bias. We observe an interesting connection between", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 367, + 505, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 358, + 382 + ], + "score": 1.0, + "content": "MAML and the stochastic composition problem. Let us define", + "type": "text" + }, + { + "bbox": [ + 358, + 368, + 449, + 380 + ], + "score": 0.93, + "content": "u _ { \\mathbf { h } } ( \\theta , T ) = u ( \\bar { \\theta } , T ; \\mathbf { h } )", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 367, + 467, + 382 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 468, + 367, + 505, + 381 + ], + "score": 0.92, + "content": "f _ { \\mathbf { g } } ^ { T } ( \\theta ) =", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 107, + 379, + 363, + 395 + ], + "spans": [ + { + "bbox": [ + 107, + 380, + 156, + 393 + ], + "score": 0.92, + "content": "f ^ { T } ( \\theta + \\sigma \\mathbf { g } )", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 379, + 227, + 395 + ], + "score": 1.0, + "content": ". For a given task", + "type": "text" + }, + { + "bbox": [ + 227, + 382, + 235, + 391 + ], + "score": 0.78, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 236, + 379, + 363, + 395 + ], + "score": 1.0, + "content": ", the MAML reward is given by", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22.5 + }, + { + "type": "interline_equation", + "bbox": [ + 190, + 397, + 420, + 415 + ], + "lines": [ + { + "bbox": [ + 190, + 397, + 420, + 415 + ], + "spans": [ + { + "bbox": [ + 190, + 397, + 420, + 415 + ], + "score": 0.91, + "content": "\\widetilde { f } ^ { T } ( U ( \\theta , T ) ) = \\widetilde { f } ^ { T } [ \\mathbb { E } _ { \\mathbf { h } } u _ { \\mathbf { h } } ( \\theta , T ) ] = \\mathbb { E } _ { \\mathbf { g } } f _ { \\mathbf { g } } ^ { T } ( \\mathbb { E } _ { \\mathbf { h } } u _ { \\mathbf { h } } ( \\theta , T ) ) .", + "type": "interline_equation", + "image_path": "89f29a564c7718b51558fdcba16f671748d2161f18863fc4d69acc611eda1ced.jpg" + } + ] + } + ], + "index": 25, + "virtual_lines": [ + { + "bbox": [ + 190, + 397, + 420, + 415 + ], + "spans": [], + "index": 25 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 421, + 505, + 468 + ], + "lines": [ + { + "bbox": [ + 104, + 419, + 507, + 438 + ], + "spans": [ + { + "bbox": [ + 104, + 419, + 431, + 438 + ], + "score": 1.0, + "content": "This is a two-layer nested stochastic composition problem with outer function", + "type": "text" + }, + { + "bbox": [ + 431, + 419, + 486, + 435 + ], + "score": 0.93, + "content": "\\tilde { f } ^ { T } = \\mathbb { E } _ { \\mathbf { g } } f _ { \\mathbf { g } } ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 419, + 507, + 438 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 104, + 433, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 104, + 433, + 165, + 448 + ], + "score": 1.0, + "content": "inner function", + "type": "text" + }, + { + "bbox": [ + 165, + 434, + 255, + 446 + ], + "score": 0.93, + "content": "U ( \\cdot , T ) = \\mathbb { E } _ { \\mathbf { h } } u _ { \\mathbf { h } } ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 433, + 505, + 448 + ], + "score": 1.0, + "content": ". An accelerated algorithm (ASC-PG) was developed in (Wang", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 444, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 323, + 459 + ], + "score": 1.0, + "content": "et al., 2017)] for this class of problems. While neither", + "type": "text" + }, + { + "bbox": [ + 323, + 444, + 336, + 458 + ], + "score": 0.9, + "content": "f _ { \\mathbf { g } } ^ { \\breve { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 444, + 353, + 459 + ], + "score": 1.0, + "content": "nor", + "type": "text" + }, + { + "bbox": [ + 353, + 445, + 388, + 457 + ], + "score": 0.93, + "content": "u _ { \\mathbf { h } } ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 444, + 506, + 459 + ], + "score": 1.0, + "content": "is smooth, which is assumed", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 456, + 448, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 448, + 468 + ], + "score": 1.0, + "content": "in (Wang et al., 2017), we can verify that the crucial content of the assumptions hold:", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 131, + 476, + 238, + 489 + ], + "lines": [ + { + "bbox": [ + 129, + 475, + 237, + 491 + ], + "spans": [ + { + "bbox": [ + 129, + 475, + 141, + 491 + ], + "score": 1.0, + "content": "1.", + "type": "text" + }, + { + "bbox": [ + 142, + 476, + 237, + 489 + ], + "score": 0.84, + "content": "\\mathbb { E } _ { \\mathbf { h } } u _ { \\mathbf { h } } ( \\theta , T ) = U ( \\theta , T )", + "type": "inline_equation" + } + ], + "index": 30 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 130, + 491, + 258, + 502 + ], + "lines": [ + { + "bbox": [ + 129, + 491, + 258, + 504 + ], + "spans": [ + { + "bbox": [ + 129, + 491, + 258, + 504 + ], + "score": 1.0, + "content": "2. We can define two functions", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "interline_equation", + "bbox": [ + 198, + 505, + 449, + 529 + ], + "lines": [ + { + "bbox": [ + 198, + 505, + 449, + 529 + ], + "spans": [ + { + "bbox": [ + 198, + 505, + 449, + 529 + ], + "score": 0.93, + "content": "\\zeta _ { \\mathbf { g } } ^ { T } ( \\theta ) = { \\frac { 1 } { \\sigma } } f _ { \\mathbf { g } } ^ { T } ( \\theta ) \\mathbf { g } , \\quad \\xi _ { \\mathbf { h } } ^ { T } ( \\theta ) = \\mathbf { I } + { \\frac { \\alpha } { \\sigma ^ { 2 } } } { \\big ( } f _ { \\mathbf { h } } ^ { T } ( \\theta ) \\mathbf { h } \\mathbf { h } ^ { T } - f _ { \\mathbf { h } } ^ { T } ( \\theta ) \\mathbf { I } { \\big ) }", + "type": "interline_equation", + "image_path": "3128d095eca7987e9ebcbe3011bdde237a1c23a18d72590d8bb1a4dd179ed60c.jpg" + } + ] + } + ], + "index": 32, + "virtual_lines": [ + { + "bbox": [ + 198, + 505, + 449, + 529 + ], + "spans": [], + "index": 32 + } + ] + }, + { + "type": "text", + "bbox": [ + 142, + 533, + 239, + 545 + ], + "lines": [ + { + "bbox": [ + 141, + 531, + 240, + 547 + ], + "spans": [ + { + "bbox": [ + 141, + 531, + 211, + 547 + ], + "score": 1.0, + "content": "such that for any", + "type": "text" + }, + { + "bbox": [ + 212, + 533, + 235, + 545 + ], + "score": 0.91, + "content": "\\theta _ { 1 } , \\theta _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 531, + 240, + 547 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 33 + }, + { + "type": "interline_equation", + "bbox": [ + 234, + 549, + 412, + 566 + ], + "lines": [ + { + "bbox": [ + 234, + 549, + 412, + 566 + ], + "spans": [ + { + "bbox": [ + 234, + 549, + 412, + 566 + ], + "score": 0.91, + "content": "\\mathbb { E } _ { \\mathbf { g } , \\mathbf { h } } [ \\xi _ { \\mathbf { h } } ^ { T } ( \\theta _ { 1 } ) \\zeta _ { \\mathbf { g } } ^ { T } ( \\theta _ { 2 } ) ] = J U ( \\theta _ { 1 } , T ) \\nabla \\widetilde { f } ^ { T } ( \\theta _ { 2 } )", + "type": "interline_equation", + "image_path": "343eb8ab03a38d8ce493262ebbc723f1355e917b00f8437eb604266bf12d69ef.jpg" + } + ] + } + ], + "index": 34, + "virtual_lines": [ + { + "bbox": [ + 234, + 549, + 412, + 566 + ], + "spans": [], + "index": 34 + } + ] + }, + { + "type": "text", + "bbox": [ + 142, + 570, + 504, + 594 + ], + "lines": [ + { + "bbox": [ + 141, + 569, + 505, + 584 + ], + "spans": [ + { + "bbox": [ + 141, + 569, + 169, + 584 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 169, + 571, + 185, + 581 + ], + "score": 0.81, + "content": "J U", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 569, + 281, + 584 + ], + "score": 1.0, + "content": "denotes the Jacobian of", + "type": "text" + }, + { + "bbox": [ + 281, + 571, + 312, + 583 + ], + "score": 0.93, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 312, + 569, + 332, + 584 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 332, + 571, + 351, + 582 + ], + "score": 0.56, + "content": "\\mathbf { g } , \\mathbf { h }", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 569, + 505, + 584 + ], + "score": 1.0, + "content": "are independent vectors sampled from", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 143, + 581, + 418, + 595 + ], + "spans": [ + { + "bbox": [ + 143, + 582, + 174, + 594 + ], + "score": 0.91, + "content": "\\mathcal { N } ( 0 , \\bf { I } )", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 581, + 418, + 595 + ], + "score": 1.0, + "content": ". This follows immediately from equation 4 and equation 10.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 106, + 601, + 505, + 658 + ], + "lines": [ + { + "bbox": [ + 105, + 601, + 505, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 505, + 616 + ], + "score": 1.0, + "content": "The ASC-PG algorithm does not immediately extend to the full MAML problem, as upon taking", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 612, + 507, + 628 + ], + "spans": [ + { + "bbox": [ + 104, + 612, + 215, + 628 + ], + "score": 1.0, + "content": "an outer expectation over", + "type": "text" + }, + { + "bbox": [ + 215, + 614, + 223, + 623 + ], + "score": 0.78, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 224, + 612, + 311, + 628 + ], + "score": 1.0, + "content": ", the MAML reward", + "type": "text" + }, + { + "bbox": [ + 311, + 613, + 442, + 626 + ], + "score": 0.93, + "content": "J ( \\theta ) = \\mathbb { E } _ { T } \\mathbb { E } _ { \\mathbf { g } } f _ { \\mathbf { g } } ^ { T } ( \\mathbb { E } _ { \\mathbf { h } } \\dot { u } _ { \\mathbf { h } } ( \\theta , T ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 442, + 612, + 507, + 628 + ], + "score": 1.0, + "content": "is no longer a", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 624, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 506, + 637 + ], + "score": 1.0, + "content": "stochastic composition of the required form. In particular, there are conceptual difficulties when the", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 635, + 506, + 648 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 183, + 648 + ], + "score": 1.0, + "content": "number of tasks in", + "type": "text" + }, + { + "bbox": [ + 183, + 636, + 192, + 646 + ], + "score": 0.83, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 193, + 635, + 506, + 648 + ], + "score": 1.0, + "content": "is infinite. However, it can be used to solve the MAML problem for each task", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 646, + 421, + 658 + ], + "spans": [ + { + "bbox": [ + 106, + 646, + 421, + 658 + ], + "score": 1.0, + "content": "within a consensus framework, such as consensus ADMM (Hong et al., 2016).", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 39 + }, + { + "type": "title", + "bbox": [ + 108, + 673, + 240, + 686 + ], + "lines": [ + { + "bbox": [ + 105, + 671, + 241, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 241, + 689 + ], + "score": 1.0, + "content": "A.3 EXTENSIONS OF ES", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 107, + 698, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "In this section, we discuss several general techniques for improving the basic ES gradient estimator", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 710, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 504, + 722 + ], + "score": 1.0, + "content": "(Algorithm 1). These can be applied both to the ES gradient of the meta-training (the ‘outer loop’", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 720, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 459, + 734 + ], + "score": 1.0, + "content": "of Algorithm 3), and more interestingly, to the adaptation operator itself. That is, given", + "type": "text" + }, + { + "bbox": [ + 460, + 720, + 505, + 732 + ], + "score": 0.93, + "content": "U ( \\theta , T ) \\stackrel { \\textstyle - } { = }", + "type": "inline_equation" + } + ], + "index": 45 + } + ], + "index": 44 + } + ], + "page_idx": 13, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 763 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 763 + ], + "score": 1.0, + "content": "14", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 81, + 505, + 118 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 316, + 95 + ], + "score": 1.0, + "content": "In the case of ES-MAML, the adaptation operator is", + "type": "text" + }, + { + "bbox": [ + 316, + 81, + 489, + 94 + ], + "score": 0.92, + "content": "U ( \\theta , T ) = \\theta + \\underline { { { \\alpha } } } \\nabla \\widetilde { f } ( \\theta , T ) = \\mathbb { E } _ { \\mathbf { h } } u ( \\theta , T ; \\mathbf { h } )", + "type": "inline_equation" + }, + { + "bbox": [ + 490, + 81, + 505, + 95 + ], + "score": 1.0, + "content": "for", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 92, + 506, + 108 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 160, + 106 + ], + "score": 0.92, + "content": "\\mathbf { h } \\sim { \\mathcal { N } } ( 0 , I )", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 92, + 191, + 108 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 191, + 93, + 328, + 106 + ], + "score": 0.92, + "content": "\\begin{array} { r } { u ( \\theta , T ; { \\bf h } ) = \\dot { \\theta } + \\frac { \\alpha } { \\sigma } f ^ { \\top } ( \\theta + \\sigma { \\bf h } ) { \\bf h } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 328, + 92, + 367, + 108 + ], + "score": 1.0, + "content": ". Clearly,", + "type": "text" + }, + { + "bbox": [ + 367, + 93, + 428, + 106 + ], + "score": 0.9, + "content": "f ^ { T } ( u ( \\theta , T ; \\mathbf { h } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 92, + 506, + 108 + ], + "score": 1.0, + "content": "is not an unbiased", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 215, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 157, + 119 + ], + "score": 1.0, + "content": "estimator of", + "type": "text" + }, + { + "bbox": [ + 157, + 105, + 210, + 119 + ], + "score": 0.93, + "content": "f ^ { \\mathcal { T } } ( U ( \\theta , T ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 104, + 215, + 119 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 105, + 81, + 506, + 119 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 122, + 505, + 189 + ], + "lines": [ + { + "bbox": [ + 105, + 122, + 506, + 136 + ], + "spans": [ + { + "bbox": [ + 105, + 122, + 347, + 136 + ], + "score": 1.0, + "content": "We may question whether using an unbiased estimator of", + "type": "text" + }, + { + "bbox": [ + 347, + 122, + 400, + 135 + ], + "score": 0.93, + "content": "f ^ { T } ( U ( \\theta , T ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 122, + 506, + 136 + ], + "score": 1.0, + "content": "is likely to improve per-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 135, + 505, + 146 + ], + "spans": [ + { + "bbox": [ + 106, + 135, + 505, + 146 + ], + "score": 1.0, + "content": "formance. One natural strategy is to reformulate the objective function so as to make the desired", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 145, + 505, + 158 + ], + "spans": [ + { + "bbox": [ + 106, + 145, + 505, + 158 + ], + "score": 1.0, + "content": "estimator unbiased. This happens to be the case for the algorithm E-MAML (Al-Shedivat et al.,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 156, + 505, + 169 + ], + "spans": [ + { + "bbox": [ + 106, + 156, + 391, + 169 + ], + "score": 1.0, + "content": "2018), which treats the adaptation operator as an explicit function of", + "type": "text" + }, + { + "bbox": [ + 392, + 156, + 402, + 166 + ], + "score": 0.82, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 156, + 505, + 169 + ], + "score": 1.0, + "content": "sampled trajectories and", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 166, + 506, + 181 + ], + "spans": [ + { + "bbox": [ + 105, + 166, + 420, + 181 + ], + "score": 1.0, + "content": "“moves the expectation outside”. That is, we now have an adaptation operator", + "type": "text" + }, + { + "bbox": [ + 421, + 167, + 501, + 179 + ], + "score": 0.92, + "content": "U ( \\theta , T ; \\tau _ { 1 } , \\dots , \\tau _ { K } )", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 166, + 506, + 181 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 177, + 250, + 191 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 250, + 191 + ], + "score": 1.0, + "content": "and the objective function becomes", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.5, + "bbox_fs": [ + 105, + 122, + 506, + 191 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 210, + 194, + 401, + 210 + ], + "lines": [ + { + "bbox": [ + 210, + 194, + 401, + 210 + ], + "spans": [ + { + "bbox": [ + 210, + 194, + 401, + 210 + ], + "score": 0.92, + "content": "\\mathbb { E } _ { T } [ \\mathbb { E } _ { \\tau _ { 1 } , \\dots , \\tau _ { k } \\sim \\mathcal { P } _ { T } ( \\tau | \\theta ) } f ^ { T } ( U ( \\theta , T ; \\tau _ { 1 } , \\dots , \\tau _ { K } ) ) ]", + "type": "interline_equation", + "image_path": "5666b55ebe64c65d62012adf6908d58e87a6dece3107c4bf8b9dd33ddc11f47a.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 210, + 194, + 401, + 210 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 213, + 505, + 258 + ], + "lines": [ + { + "bbox": [ + 105, + 213, + 505, + 226 + ], + "spans": [ + { + "bbox": [ + 105, + 213, + 483, + 226 + ], + "score": 1.0, + "content": "An unbiased estimator for the E-MAML gradient can be obtained by sampling only from", + "type": "text" + }, + { + "bbox": [ + 484, + 216, + 505, + 224 + ], + "score": 0.81, + "content": "\\tau \\sim", + "type": "inline_equation" + } + ], + "index": 10 + }, + { + "bbox": [ + 107, + 225, + 505, + 237 + ], + "spans": [ + { + "bbox": [ + 107, + 225, + 142, + 237 + ], + "score": 0.92, + "content": "{ \\mathcal { P } } _ { T } ( \\tau | \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 225, + 505, + 237 + ], + "score": 1.0, + "content": "(Al-Shedivat et al., 2018). However, it has been argued that by doing so, E-MAML does", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 235, + 505, + 248 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 505, + 248 + ], + "score": 1.0, + "content": "not properly assign credit to the pre-adaptation policy (Rothfuss et al., 2019). Thus, this particular", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 247, + 345, + 258 + ], + "spans": [ + { + "bbox": [ + 105, + 247, + 345, + 258 + ], + "score": 1.0, + "content": "mathematical strategy seems to be disadvantageous for RL.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 213, + 505, + 258 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 263, + 505, + 341 + ], + "lines": [ + { + "bbox": [ + 106, + 263, + 505, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 263, + 358, + 276 + ], + "score": 1.0, + "content": "The problem of finding estimators for function-of-expectations", + "type": "text" + }, + { + "bbox": [ + 358, + 264, + 388, + 276 + ], + "score": 0.93, + "content": "f ( \\mathbb { E } X )", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 263, + 505, + 276 + ], + "score": 1.0, + "content": "is difficult and while general", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 275, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 106, + 275, + 505, + 286 + ], + "score": 1.0, + "content": "unbiased estimation methods exist (Blanchet et al., 2017), they are often complicated and suffer", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 285, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 106, + 285, + 505, + 298 + ], + "score": 1.0, + "content": "from high variance. In the context of MAML, ProMP compares the low variance curvature (LVC)", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 297, + 506, + 308 + ], + "spans": [ + { + "bbox": [ + 106, + 297, + 506, + 308 + ], + "score": 1.0, + "content": "estimator (Rothfuss et al., 2019), which is biased, against the unbiased DiCE estimator (Foerster", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 307, + 506, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 506, + 319 + ], + "score": 1.0, + "content": "et al., 2018), for the Hessian term in the MAML gradient, and found that the lower variance of LVC", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 318, + 506, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 506, + 331 + ], + "score": 1.0, + "content": "produced better performance than DiCE. Alternatively, control variates can be used to reduce the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 329, + 445, + 342 + ], + "spans": [ + { + "bbox": [ + 106, + 329, + 445, + 342 + ], + "score": 1.0, + "content": "variance of the DiCE estimator, which is the approach followed in (Liu et al., 2019).", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 263, + 506, + 342 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 345, + 505, + 393 + ], + "lines": [ + { + "bbox": [ + 105, + 345, + 506, + 359 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 452, + 359 + ], + "score": 1.0, + "content": "In the ES framework, the problem can also be formulated to avoid exactly evaluating", + "type": "text" + }, + { + "bbox": [ + 453, + 346, + 483, + 358 + ], + "score": 0.92, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 345, + 506, + 359 + ], + "score": 1.0, + "content": ", and", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 357, + 505, + 370 + ], + "spans": [ + { + "bbox": [ + 106, + 357, + 505, + 370 + ], + "score": 1.0, + "content": "hence circumvents the question of estimator bias. We observe an interesting connection between", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 367, + 505, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 358, + 382 + ], + "score": 1.0, + "content": "MAML and the stochastic composition problem. Let us define", + "type": "text" + }, + { + "bbox": [ + 358, + 368, + 449, + 380 + ], + "score": 0.93, + "content": "u _ { \\mathbf { h } } ( \\theta , T ) = u ( \\bar { \\theta } , T ; \\mathbf { h } )", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 367, + 467, + 382 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 468, + 367, + 505, + 381 + ], + "score": 0.92, + "content": "f _ { \\mathbf { g } } ^ { T } ( \\theta ) =", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 107, + 379, + 363, + 395 + ], + "spans": [ + { + "bbox": [ + 107, + 380, + 156, + 393 + ], + "score": 0.92, + "content": "f ^ { T } ( \\theta + \\sigma \\mathbf { g } )", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 379, + 227, + 395 + ], + "score": 1.0, + "content": ". For a given task", + "type": "text" + }, + { + "bbox": [ + 227, + 382, + 235, + 391 + ], + "score": 0.78, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 236, + 379, + 363, + 395 + ], + "score": 1.0, + "content": ", the MAML reward is given by", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 345, + 506, + 395 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 190, + 397, + 420, + 415 + ], + "lines": [ + { + "bbox": [ + 190, + 397, + 420, + 415 + ], + "spans": [ + { + "bbox": [ + 190, + 397, + 420, + 415 + ], + "score": 0.91, + "content": "\\widetilde { f } ^ { T } ( U ( \\theta , T ) ) = \\widetilde { f } ^ { T } [ \\mathbb { E } _ { \\mathbf { h } } u _ { \\mathbf { h } } ( \\theta , T ) ] = \\mathbb { E } _ { \\mathbf { g } } f _ { \\mathbf { g } } ^ { T } ( \\mathbb { E } _ { \\mathbf { h } } u _ { \\mathbf { h } } ( \\theta , T ) ) .", + "type": "interline_equation", + "image_path": "89f29a564c7718b51558fdcba16f671748d2161f18863fc4d69acc611eda1ced.jpg" + } + ] + } + ], + "index": 25, + "virtual_lines": [ + { + "bbox": [ + 190, + 397, + 420, + 415 + ], + "spans": [], + "index": 25 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 421, + 505, + 468 + ], + "lines": [ + { + "bbox": [ + 104, + 419, + 507, + 438 + ], + "spans": [ + { + "bbox": [ + 104, + 419, + 431, + 438 + ], + "score": 1.0, + "content": "This is a two-layer nested stochastic composition problem with outer function", + "type": "text" + }, + { + "bbox": [ + 431, + 419, + 486, + 435 + ], + "score": 0.93, + "content": "\\tilde { f } ^ { T } = \\mathbb { E } _ { \\mathbf { g } } f _ { \\mathbf { g } } ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 419, + 507, + 438 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 104, + 433, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 104, + 433, + 165, + 448 + ], + "score": 1.0, + "content": "inner function", + "type": "text" + }, + { + "bbox": [ + 165, + 434, + 255, + 446 + ], + "score": 0.93, + "content": "U ( \\cdot , T ) = \\mathbb { E } _ { \\mathbf { h } } u _ { \\mathbf { h } } ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 433, + 505, + 448 + ], + "score": 1.0, + "content": ". An accelerated algorithm (ASC-PG) was developed in (Wang", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 444, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 323, + 459 + ], + "score": 1.0, + "content": "et al., 2017)] for this class of problems. While neither", + "type": "text" + }, + { + "bbox": [ + 323, + 444, + 336, + 458 + ], + "score": 0.9, + "content": "f _ { \\mathbf { g } } ^ { \\breve { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 444, + 353, + 459 + ], + "score": 1.0, + "content": "nor", + "type": "text" + }, + { + "bbox": [ + 353, + 445, + 388, + 457 + ], + "score": 0.93, + "content": "u _ { \\mathbf { h } } ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 444, + 506, + 459 + ], + "score": 1.0, + "content": "is smooth, which is assumed", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 456, + 448, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 448, + 468 + ], + "score": 1.0, + "content": "in (Wang et al., 2017), we can verify that the crucial content of the assumptions hold:", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27.5, + "bbox_fs": [ + 104, + 419, + 507, + 468 + ] + }, + { + "type": "text", + "bbox": [ + 131, + 476, + 238, + 489 + ], + "lines": [ + { + "bbox": [ + 129, + 475, + 237, + 491 + ], + "spans": [ + { + "bbox": [ + 129, + 475, + 141, + 491 + ], + "score": 1.0, + "content": "1.", + "type": "text" + }, + { + "bbox": [ + 142, + 476, + 237, + 489 + ], + "score": 0.84, + "content": "\\mathbb { E } _ { \\mathbf { h } } u _ { \\mathbf { h } } ( \\theta , T ) = U ( \\theta , T )", + "type": "inline_equation" + } + ], + "index": 30 + } + ], + "index": 30, + "bbox_fs": [ + 129, + 475, + 237, + 491 + ] + }, + { + "type": "text", + "bbox": [ + 130, + 491, + 258, + 502 + ], + "lines": [ + { + "bbox": [ + 129, + 491, + 258, + 504 + ], + "spans": [ + { + "bbox": [ + 129, + 491, + 258, + 504 + ], + "score": 1.0, + "content": "2. We can define two functions", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31, + "bbox_fs": [ + 129, + 491, + 258, + 504 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 198, + 505, + 449, + 529 + ], + "lines": [ + { + "bbox": [ + 198, + 505, + 449, + 529 + ], + "spans": [ + { + "bbox": [ + 198, + 505, + 449, + 529 + ], + "score": 0.93, + "content": "\\zeta _ { \\mathbf { g } } ^ { T } ( \\theta ) = { \\frac { 1 } { \\sigma } } f _ { \\mathbf { g } } ^ { T } ( \\theta ) \\mathbf { g } , \\quad \\xi _ { \\mathbf { h } } ^ { T } ( \\theta ) = \\mathbf { I } + { \\frac { \\alpha } { \\sigma ^ { 2 } } } { \\big ( } f _ { \\mathbf { h } } ^ { T } ( \\theta ) \\mathbf { h } \\mathbf { h } ^ { T } - f _ { \\mathbf { h } } ^ { T } ( \\theta ) \\mathbf { I } { \\big ) }", + "type": "interline_equation", + "image_path": "3128d095eca7987e9ebcbe3011bdde237a1c23a18d72590d8bb1a4dd179ed60c.jpg" + } + ] + } + ], + "index": 32, + "virtual_lines": [ + { + "bbox": [ + 198, + 505, + 449, + 529 + ], + "spans": [], + "index": 32 + } + ] + }, + { + "type": "text", + "bbox": [ + 142, + 533, + 239, + 545 + ], + "lines": [ + { + "bbox": [ + 141, + 531, + 240, + 547 + ], + "spans": [ + { + "bbox": [ + 141, + 531, + 211, + 547 + ], + "score": 1.0, + "content": "such that for any", + "type": "text" + }, + { + "bbox": [ + 212, + 533, + 235, + 545 + ], + "score": 0.91, + "content": "\\theta _ { 1 } , \\theta _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 531, + 240, + 547 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 33, + "bbox_fs": [ + 141, + 531, + 240, + 547 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 234, + 549, + 412, + 566 + ], + "lines": [ + { + "bbox": [ + 234, + 549, + 412, + 566 + ], + "spans": [ + { + "bbox": [ + 234, + 549, + 412, + 566 + ], + "score": 0.91, + "content": "\\mathbb { E } _ { \\mathbf { g } , \\mathbf { h } } [ \\xi _ { \\mathbf { h } } ^ { T } ( \\theta _ { 1 } ) \\zeta _ { \\mathbf { g } } ^ { T } ( \\theta _ { 2 } ) ] = J U ( \\theta _ { 1 } , T ) \\nabla \\widetilde { f } ^ { T } ( \\theta _ { 2 } )", + "type": "interline_equation", + "image_path": "343eb8ab03a38d8ce493262ebbc723f1355e917b00f8437eb604266bf12d69ef.jpg" + } + ] + } + ], + "index": 34, + "virtual_lines": [ + { + "bbox": [ + 234, + 549, + 412, + 566 + ], + "spans": [], + "index": 34 + } + ] + }, + { + "type": "text", + "bbox": [ + 142, + 570, + 504, + 594 + ], + "lines": [ + { + "bbox": [ + 141, + 569, + 505, + 584 + ], + "spans": [ + { + "bbox": [ + 141, + 569, + 169, + 584 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 169, + 571, + 185, + 581 + ], + "score": 0.81, + "content": "J U", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 569, + 281, + 584 + ], + "score": 1.0, + "content": "denotes the Jacobian of", + "type": "text" + }, + { + "bbox": [ + 281, + 571, + 312, + 583 + ], + "score": 0.93, + "content": "U ( \\cdot , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 312, + 569, + 332, + 584 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 332, + 571, + 351, + 582 + ], + "score": 0.56, + "content": "\\mathbf { g } , \\mathbf { h }", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 569, + 505, + 584 + ], + "score": 1.0, + "content": "are independent vectors sampled from", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 143, + 581, + 418, + 595 + ], + "spans": [ + { + "bbox": [ + 143, + 582, + 174, + 594 + ], + "score": 0.91, + "content": "\\mathcal { N } ( 0 , \\bf { I } )", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 581, + 418, + 595 + ], + "score": 1.0, + "content": ". This follows immediately from equation 4 and equation 10.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5, + "bbox_fs": [ + 141, + 569, + 505, + 595 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 601, + 505, + 658 + ], + "lines": [ + { + "bbox": [ + 105, + 601, + 505, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 505, + 616 + ], + "score": 1.0, + "content": "The ASC-PG algorithm does not immediately extend to the full MAML problem, as upon taking", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 612, + 507, + 628 + ], + "spans": [ + { + "bbox": [ + 104, + 612, + 215, + 628 + ], + "score": 1.0, + "content": "an outer expectation over", + "type": "text" + }, + { + "bbox": [ + 215, + 614, + 223, + 623 + ], + "score": 0.78, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 224, + 612, + 311, + 628 + ], + "score": 1.0, + "content": ", the MAML reward", + "type": "text" + }, + { + "bbox": [ + 311, + 613, + 442, + 626 + ], + "score": 0.93, + "content": "J ( \\theta ) = \\mathbb { E } _ { T } \\mathbb { E } _ { \\mathbf { g } } f _ { \\mathbf { g } } ^ { T } ( \\mathbb { E } _ { \\mathbf { h } } \\dot { u } _ { \\mathbf { h } } ( \\theta , T ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 442, + 612, + 507, + 628 + ], + "score": 1.0, + "content": "is no longer a", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 624, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 506, + 637 + ], + "score": 1.0, + "content": "stochastic composition of the required form. In particular, there are conceptual difficulties when the", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 635, + 506, + 648 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 183, + 648 + ], + "score": 1.0, + "content": "number of tasks in", + "type": "text" + }, + { + "bbox": [ + 183, + 636, + 192, + 646 + ], + "score": 0.83, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 193, + 635, + 506, + 648 + ], + "score": 1.0, + "content": "is infinite. However, it can be used to solve the MAML problem for each task", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 646, + 421, + 658 + ], + "spans": [ + { + "bbox": [ + 106, + 646, + 421, + 658 + ], + "score": 1.0, + "content": "within a consensus framework, such as consensus ADMM (Hong et al., 2016).", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 39, + "bbox_fs": [ + 104, + 601, + 507, + 658 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 673, + 240, + 686 + ], + "lines": [ + { + "bbox": [ + 105, + 671, + 241, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 241, + 689 + ], + "score": 1.0, + "content": "A.3 EXTENSIONS OF ES", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 107, + 698, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "In this section, we discuss several general techniques for improving the basic ES gradient estimator", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 710, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 504, + 722 + ], + "score": 1.0, + "content": "(Algorithm 1). These can be applied both to the ES gradient of the meta-training (the ‘outer loop’", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 720, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 459, + 734 + ], + "score": 1.0, + "content": "of Algorithm 3), and more interestingly, to the adaptation operator itself. That is, given", + "type": "text" + }, + { + "bbox": [ + 460, + 720, + 505, + 732 + ], + "score": 0.93, + "content": "U ( \\theta , T ) \\stackrel { \\textstyle - } { = }", + "type": "inline_equation" + } + ], + "index": 45 + }, + { + "bbox": [ + 107, + 80, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 107, + 80, + 167, + 95 + ], + "score": 0.93, + "content": "\\theta + \\alpha \\nabla \\widetilde { f } _ { \\sigma } ^ { T } ( \\theta )", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 167, + 80, + 294, + 96 + ], + "score": 1.0, + "content": ", we replace the estimation of", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 294, + 83, + 304, + 92 + ], + "score": 0.78, + "content": "U", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 304, + 80, + 506, + 96 + ], + "score": 1.0, + "content": "by ESGRAD on line 4 of Algorithm 3 with an", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 110 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 198, + 110 + ], + "score": 1.0, + "content": "improved estimator of", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 198, + 93, + 232, + 108 + ], + "score": 0.93, + "content": "\\nabla \\widetilde { f } _ { \\sigma } ^ { T } ( \\theta )", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 232, + 94, + 506, + 110 + ], + "score": 1.0, + "content": ", which even may depend on data collected during the meta-training", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 107, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 107, + 505, + 119 + ], + "score": 1.0, + "content": "stage. Many techniques exist for reducing the variance of the estimator such as Quasi Monte Carlo", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 117, + 505, + 130 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 505, + 130 + ], + "score": 1.0, + "content": "sampling (Choromanski et al., 2018). Aside from variance reduction, there are also methods with", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 129, + 181, + 141 + ], + "spans": [ + { + "bbox": [ + 105, + 129, + 181, + 141 + ], + "score": 1.0, + "content": "special properties.", + "type": "text", + "cross_page": true + } + ], + "index": 4 + } + ], + "index": 44, + "bbox_fs": [ + 105, + 698, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 81, + 505, + 140 + ], + "lines": [ + { + "bbox": [ + 107, + 80, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 107, + 80, + 167, + 95 + ], + "score": 0.93, + "content": "\\theta + \\alpha \\nabla \\widetilde { f } _ { \\sigma } ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 80, + 294, + 96 + ], + "score": 1.0, + "content": ", we replace the estimation of", + "type": "text" + }, + { + "bbox": [ + 294, + 83, + 304, + 92 + ], + "score": 0.78, + "content": "U", + "type": "inline_equation" + }, + { + "bbox": [ + 304, + 80, + 506, + 96 + ], + "score": 1.0, + "content": "by ESGRAD on line 4 of Algorithm 3 with an", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 110 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 198, + 110 + ], + "score": 1.0, + "content": "improved estimator of", + "type": "text" + }, + { + "bbox": [ + 198, + 93, + 232, + 108 + ], + "score": 0.93, + "content": "\\nabla \\widetilde { f } _ { \\sigma } ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 232, + 94, + 506, + 110 + ], + "score": 1.0, + "content": ", which even may depend on data collected during the meta-training", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 107, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 107, + 505, + 119 + ], + "score": 1.0, + "content": "stage. Many techniques exist for reducing the variance of the estimator such as Quasi Monte Carlo", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 117, + 505, + 130 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 505, + 130 + ], + "score": 1.0, + "content": "sampling (Choromanski et al., 2018). Aside from variance reduction, there are also methods with", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 129, + 181, + 141 + ], + "spans": [ + { + "bbox": [ + 105, + 129, + 181, + 141 + ], + "score": 1.0, + "content": "special properties.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2 + }, + { + "type": "title", + "bbox": [ + 108, + 155, + 226, + 167 + ], + "lines": [ + { + "bbox": [ + 106, + 154, + 228, + 168 + ], + "spans": [ + { + "bbox": [ + 106, + 154, + 228, + 168 + ], + "score": 1.0, + "content": "A.3.1 ACTIVE SUBSPACES", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 106, + 176, + 505, + 298 + ], + "lines": [ + { + "bbox": [ + 106, + 177, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 505, + 189 + ], + "score": 1.0, + "content": "Active Subspaces is a method for finding a low-dimensional subspace where the contribution of the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 187, + 506, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 506, + 201 + ], + "score": 1.0, + "content": "gradient is maximized. Conceptually, the goal is to find and update on-the-fly a low-rank subspace", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 107, + 197, + 506, + 212 + ], + "spans": [ + { + "bbox": [ + 107, + 199, + 115, + 209 + ], + "score": 0.77, + "content": "\\mathcal { L }", + "type": "inline_equation" + }, + { + "bbox": [ + 115, + 197, + 204, + 212 + ], + "score": 1.0, + "content": "so that the projection", + "type": "text" + }, + { + "bbox": [ + 204, + 198, + 244, + 211 + ], + "score": 0.93, + "content": "\\nabla f ^ { T } ( \\boldsymbol { \\theta } ) _ { \\mathcal { L } }", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 197, + 258, + 212 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 258, + 198, + 292, + 210 + ], + "score": 0.92, + "content": "\\nabla f ^ { \\mathbf { \\nabla } } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 292, + 197, + 312, + 212 + ], + "score": 1.0, + "content": "into", + "type": "text" + }, + { + "bbox": [ + 312, + 199, + 320, + 208 + ], + "score": 0.82, + "content": "\\mathcal { L }", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 197, + 421, + 212 + ], + "score": 1.0, + "content": "is maximized and apply", + "type": "text" + }, + { + "bbox": [ + 421, + 198, + 461, + 211 + ], + "score": 0.93, + "content": "\\nabla f ^ { T } ( \\theta ) _ { \\mathcal { L } }", + "type": "inline_equation" + }, + { + "bbox": [ + 461, + 197, + 506, + 212 + ], + "score": 1.0, + "content": "instead of", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 107, + 208, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 107, + 209, + 141, + 222 + ], + "score": 0.92, + "content": "\\nabla f ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 208, + 305, + 223 + ], + "score": 1.0, + "content": ". This should be done in such a way that", + "type": "text" + }, + { + "bbox": [ + 305, + 209, + 339, + 222 + ], + "score": 0.92, + "content": "\\nabla f ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 208, + 505, + 223 + ], + "score": 1.0, + "content": "does not need to be computed explicitly.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 221, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 106, + 221, + 505, + 234 + ], + "score": 1.0, + "content": "Optimizing in lower-dimensional subspaces might be computationally more efficient and can be", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 231, + 506, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 506, + 245 + ], + "score": 1.0, + "content": "thought of as an example of guided ES methods, where the algorithm is guided how to explore space", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 243, + 506, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 506, + 255 + ], + "score": 1.0, + "content": "in the anisotropic way, leveraging its knowledge about function optimization landscape that it gained", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 254, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 505, + 266 + ], + "score": 1.0, + "content": "in the previous steps of optimization. In the context of RL, the active subspace method ASEBO", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 264, + 505, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 505, + 277 + ], + "score": 1.0, + "content": "(Choromanski et al., 2019b) was successfully applied to speed up policy training algorithms. This", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 275, + 506, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 506, + 289 + ], + "score": 1.0, + "content": "strategy can be made data-dependent also in the MAML context, by learning an optimal subspace", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 287, + 491, + 299 + ], + "spans": [ + { + "bbox": [ + 106, + 287, + 491, + 299 + ], + "score": 1.0, + "content": "using data from the meta-training stage, and sampling from that subspace in the adaptation step.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 11 + }, + { + "type": "title", + "bbox": [ + 108, + 313, + 297, + 324 + ], + "lines": [ + { + "bbox": [ + 105, + 312, + 299, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 312, + 299, + 326 + ], + "score": 1.0, + "content": "A.3.2 REGRESSION-BASED OPTIMIZATION", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 334, + 505, + 412 + ], + "lines": [ + { + "bbox": [ + 105, + 334, + 506, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 506, + 347 + ], + "score": 1.0, + "content": "Regression-Based Optimization (RBO) is an alternative method of gradient estimation. From Taylor", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 344, + 505, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 214, + 358 + ], + "score": 1.0, + "content": "series expansion we have", + "type": "text" + }, + { + "bbox": [ + 214, + 345, + 393, + 357 + ], + "score": 0.93, + "content": "f ( { \\boldsymbol { \\theta } } + \\mathbf { d } ) - f ( { \\boldsymbol { \\theta } } ) = \\nabla f ( { \\boldsymbol { \\theta } } ) ^ { T } \\mathbf { d } + O ( \\| \\mathbf { \\bar { d } } \\| ^ { 2 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 394, + 344, + 505, + 358 + ], + "score": 1.0, + "content": ". By taking multiple finite", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 356, + 506, + 370 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 199, + 370 + ], + "score": 1.0, + "content": "difference expressions", + "type": "text" + }, + { + "bbox": [ + 200, + 357, + 270, + 369 + ], + "score": 0.91, + "content": "f ( \\theta + { \\bf d } ) - f ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 356, + 324, + 370 + ], + "score": 1.0, + "content": "for different", + "type": "text" + }, + { + "bbox": [ + 325, + 358, + 332, + 367 + ], + "score": 0.4, + "content": "\\mathbf { d }", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 356, + 506, + 370 + ], + "score": 1.0, + "content": ", we can recover the gradient by solving a", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 367, + 506, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 506, + 380 + ], + "score": 1.0, + "content": "regularized regression problem. The regularization has an additional advantage - it was shown that", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 378, + 506, + 391 + ], + "spans": [ + { + "bbox": [ + 106, + 378, + 408, + 391 + ], + "score": 1.0, + "content": "the gradient can be recovered even if a substantial fraction of the rewards", + "type": "text" + }, + { + "bbox": [ + 408, + 378, + 447, + 390 + ], + "score": 0.93, + "content": "f ( \\theta + { \\bf d } )", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 378, + 506, + 391 + ], + "score": 1.0, + "content": "are corrupted", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 389, + 506, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 389, + 506, + 402 + ], + "score": 1.0, + "content": "(Choromanski et al., 2019c). Strictly speaking, this is not based on the Gaussian smoothing as in", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 400, + 458, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 400, + 458, + 413 + ], + "score": 1.0, + "content": "ES, but is another method for estimating gradients using only zero-th order evaluations.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 21 + }, + { + "type": "title", + "bbox": [ + 108, + 426, + 204, + 438 + ], + "lines": [ + { + "bbox": [ + 106, + 425, + 205, + 439 + ], + "spans": [ + { + "bbox": [ + 106, + 425, + 205, + 439 + ], + "score": 1.0, + "content": "A.3.3 EXPERIMENTS", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 107, + 448, + 505, + 495 + ], + "lines": [ + { + "bbox": [ + 106, + 448, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 505, + 461 + ], + "score": 1.0, + "content": "We present a preliminary experiment with RBO and ASEBO gradient adaptation in Figure A3. To", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 459, + 506, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 423, + 472 + ], + "score": 1.0, + "content": "be precise, the algorithms used are identical to Algorithm 3 except that in line 4,", + "type": "text" + }, + { + "bbox": [ + 423, + 459, + 486, + 472 + ], + "score": 0.49, + "content": "\\mathbf { d } ^ { ( i ) } \\mathrm { \\bar { E } S G R } \\boldsymbol { \\mathit { \\Sigma } }", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 460, + 506, + 472 + ], + "score": 1.0, + "content": "D is", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 470, + 506, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 154, + 486 + ], + "score": 1.0, + "content": "replaced by", + "type": "text" + }, + { + "bbox": [ + 155, + 471, + 209, + 483 + ], + "score": 0.86, + "content": "\\mathbf { d } ^ { ( i ) } \\mathbf { R } \\mathbf { B } \\mathbf { O }", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 470, + 325, + 486 + ], + "score": 1.0, + "content": "(yielding RBO-MAML) and", + "type": "text" + }, + { + "bbox": [ + 325, + 471, + 393, + 483 + ], + "score": 0.39, + "content": "\\mathbf { d } ^ { ( i ) } \\bar { \\mathbf { A } } \\mathbf { S } \\mathbf { E } \\mathbf { B } \\mathbf { O }", + "type": "inline_equation" + }, + { + "bbox": [ + 394, + 470, + 506, + 486 + ], + "score": 1.0, + "content": "(yielding ASEBO-MAML)", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 483, + 159, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 159, + 497 + ], + "score": 1.0, + "content": "respectively.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27.5 + }, + { + "type": "image", + "bbox": [ + 125, + 530, + 483, + 665 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 159, + 516, + 451, + 528 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 158, + 516, + 452, + 531 + ], + "spans": [ + { + "bbox": [ + 158, + 516, + 452, + 531 + ], + "score": 1.0, + "content": "Figure A3: RBO-MAML and ASEBO-MAML compared to ES-MAML.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 30 + }, + { + "type": "image_body", + "bbox": [ + 125, + 530, + 483, + 665 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 125, + 530, + 483, + 665 + ], + "spans": [ + { + "bbox": [ + 125, + 530, + 483, + 665 + ], + "score": 0.969, + "type": "image", + "image_path": "944b249f7efd56cf286c8da0000c96bb66703e8e8172ad29e3928cfdcb7cea57.jpg" + } + ] + } + ], + "index": 32, + "virtual_lines": [ + { + "bbox": [ + 125, + 530, + 483, + 575.0 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 125, + 575.0, + 483, + 620.0 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 125, + 620.0, + 483, + 665.0 + ], + "spans": [], + "index": 33 + } + ] + } + ], + "index": 31.0 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "score": 1.0, + "content": "On the left plot, we test for noise robustness on the Forward-Backward Swimmer MAML task, com-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "paring standard ES-MAML (Algorithm 3) to RBO-MAML. To simulate noisy data, we randomly", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 708, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 138, + 723 + ], + "score": 1.0, + "content": "corrupt", + "type": "text" + }, + { + "bbox": [ + 138, + 709, + 158, + 720 + ], + "score": 0.88, + "content": "2 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 708, + 219, + 723 + ], + "score": 1.0, + "content": "of the queries", + "type": "text" + }, + { + "bbox": [ + 219, + 709, + 269, + 722 + ], + "score": 0.91, + "content": "f ^ { T } ( { \\overline { { \\theta } } } + \\sigma g )", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 708, + 437, + 723 + ], + "score": 1.0, + "content": "used to estimate the adaptation operator", + "type": "text" + }, + { + "bbox": [ + 437, + 710, + 470, + 722 + ], + "score": 0.93, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 708, + 506, + 723 + ], + "score": 1.0, + "content": "with an", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "enormous additive noise. This is the same type of corruption used in (Choromanski et al., 2019c).", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5 + } + ], + "page_idx": 14, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "15", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 81, + 505, + 140 + ], + "lines": [], + "index": 2, + "bbox_fs": [ + 105, + 80, + 506, + 141 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 108, + 155, + 226, + 167 + ], + "lines": [ + { + "bbox": [ + 106, + 154, + 228, + 168 + ], + "spans": [ + { + "bbox": [ + 106, + 154, + 228, + 168 + ], + "score": 1.0, + "content": "A.3.1 ACTIVE SUBSPACES", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 106, + 176, + 505, + 298 + ], + "lines": [ + { + "bbox": [ + 106, + 177, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 505, + 189 + ], + "score": 1.0, + "content": "Active Subspaces is a method for finding a low-dimensional subspace where the contribution of the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 187, + 506, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 506, + 201 + ], + "score": 1.0, + "content": "gradient is maximized. Conceptually, the goal is to find and update on-the-fly a low-rank subspace", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 107, + 197, + 506, + 212 + ], + "spans": [ + { + "bbox": [ + 107, + 199, + 115, + 209 + ], + "score": 0.77, + "content": "\\mathcal { L }", + "type": "inline_equation" + }, + { + "bbox": [ + 115, + 197, + 204, + 212 + ], + "score": 1.0, + "content": "so that the projection", + "type": "text" + }, + { + "bbox": [ + 204, + 198, + 244, + 211 + ], + "score": 0.93, + "content": "\\nabla f ^ { T } ( \\boldsymbol { \\theta } ) _ { \\mathcal { L } }", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 197, + 258, + 212 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 258, + 198, + 292, + 210 + ], + "score": 0.92, + "content": "\\nabla f ^ { \\mathbf { \\nabla } } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 292, + 197, + 312, + 212 + ], + "score": 1.0, + "content": "into", + "type": "text" + }, + { + "bbox": [ + 312, + 199, + 320, + 208 + ], + "score": 0.82, + "content": "\\mathcal { L }", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 197, + 421, + 212 + ], + "score": 1.0, + "content": "is maximized and apply", + "type": "text" + }, + { + "bbox": [ + 421, + 198, + 461, + 211 + ], + "score": 0.93, + "content": "\\nabla f ^ { T } ( \\theta ) _ { \\mathcal { L } }", + "type": "inline_equation" + }, + { + "bbox": [ + 461, + 197, + 506, + 212 + ], + "score": 1.0, + "content": "instead of", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 107, + 208, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 107, + 209, + 141, + 222 + ], + "score": 0.92, + "content": "\\nabla f ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 208, + 305, + 223 + ], + "score": 1.0, + "content": ". This should be done in such a way that", + "type": "text" + }, + { + "bbox": [ + 305, + 209, + 339, + 222 + ], + "score": 0.92, + "content": "\\nabla f ^ { T } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 208, + 505, + 223 + ], + "score": 1.0, + "content": "does not need to be computed explicitly.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 221, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 106, + 221, + 505, + 234 + ], + "score": 1.0, + "content": "Optimizing in lower-dimensional subspaces might be computationally more efficient and can be", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 231, + 506, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 506, + 245 + ], + "score": 1.0, + "content": "thought of as an example of guided ES methods, where the algorithm is guided how to explore space", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 243, + 506, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 506, + 255 + ], + "score": 1.0, + "content": "in the anisotropic way, leveraging its knowledge about function optimization landscape that it gained", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 254, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 505, + 266 + ], + "score": 1.0, + "content": "in the previous steps of optimization. In the context of RL, the active subspace method ASEBO", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 264, + 505, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 505, + 277 + ], + "score": 1.0, + "content": "(Choromanski et al., 2019b) was successfully applied to speed up policy training algorithms. This", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 275, + 506, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 506, + 289 + ], + "score": 1.0, + "content": "strategy can be made data-dependent also in the MAML context, by learning an optimal subspace", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 287, + 491, + 299 + ], + "spans": [ + { + "bbox": [ + 106, + 287, + 491, + 299 + ], + "score": 1.0, + "content": "using data from the meta-training stage, and sampling from that subspace in the adaptation step.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 11, + "bbox_fs": [ + 105, + 177, + 506, + 299 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 313, + 297, + 324 + ], + "lines": [ + { + "bbox": [ + 105, + 312, + 299, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 312, + 299, + 326 + ], + "score": 1.0, + "content": "A.3.2 REGRESSION-BASED OPTIMIZATION", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 334, + 505, + 412 + ], + "lines": [ + { + "bbox": [ + 105, + 334, + 506, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 506, + 347 + ], + "score": 1.0, + "content": "Regression-Based Optimization (RBO) is an alternative method of gradient estimation. From Taylor", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 344, + 505, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 214, + 358 + ], + "score": 1.0, + "content": "series expansion we have", + "type": "text" + }, + { + "bbox": [ + 214, + 345, + 393, + 357 + ], + "score": 0.93, + "content": "f ( { \\boldsymbol { \\theta } } + \\mathbf { d } ) - f ( { \\boldsymbol { \\theta } } ) = \\nabla f ( { \\boldsymbol { \\theta } } ) ^ { T } \\mathbf { d } + O ( \\| \\mathbf { \\bar { d } } \\| ^ { 2 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 394, + 344, + 505, + 358 + ], + "score": 1.0, + "content": ". By taking multiple finite", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 356, + 506, + 370 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 199, + 370 + ], + "score": 1.0, + "content": "difference expressions", + "type": "text" + }, + { + "bbox": [ + 200, + 357, + 270, + 369 + ], + "score": 0.91, + "content": "f ( \\theta + { \\bf d } ) - f ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 356, + 324, + 370 + ], + "score": 1.0, + "content": "for different", + "type": "text" + }, + { + "bbox": [ + 325, + 358, + 332, + 367 + ], + "score": 0.4, + "content": "\\mathbf { d }", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 356, + 506, + 370 + ], + "score": 1.0, + "content": ", we can recover the gradient by solving a", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 367, + 506, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 506, + 380 + ], + "score": 1.0, + "content": "regularized regression problem. The regularization has an additional advantage - it was shown that", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 378, + 506, + 391 + ], + "spans": [ + { + "bbox": [ + 106, + 378, + 408, + 391 + ], + "score": 1.0, + "content": "the gradient can be recovered even if a substantial fraction of the rewards", + "type": "text" + }, + { + "bbox": [ + 408, + 378, + 447, + 390 + ], + "score": 0.93, + "content": "f ( \\theta + { \\bf d } )", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 378, + 506, + 391 + ], + "score": 1.0, + "content": "are corrupted", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 389, + 506, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 389, + 506, + 402 + ], + "score": 1.0, + "content": "(Choromanski et al., 2019c). Strictly speaking, this is not based on the Gaussian smoothing as in", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 400, + 458, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 400, + 458, + 413 + ], + "score": 1.0, + "content": "ES, but is another method for estimating gradients using only zero-th order evaluations.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 334, + 506, + 413 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 426, + 204, + 438 + ], + "lines": [ + { + "bbox": [ + 106, + 425, + 205, + 439 + ], + "spans": [ + { + "bbox": [ + 106, + 425, + 205, + 439 + ], + "score": 1.0, + "content": "A.3.3 EXPERIMENTS", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 107, + 448, + 505, + 495 + ], + "lines": [ + { + "bbox": [ + 106, + 448, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 505, + 461 + ], + "score": 1.0, + "content": "We present a preliminary experiment with RBO and ASEBO gradient adaptation in Figure A3. To", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 459, + 506, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 423, + 472 + ], + "score": 1.0, + "content": "be precise, the algorithms used are identical to Algorithm 3 except that in line 4,", + "type": "text" + }, + { + "bbox": [ + 423, + 459, + 486, + 472 + ], + "score": 0.49, + "content": "\\mathbf { d } ^ { ( i ) } \\mathrm { \\bar { E } S G R } \\boldsymbol { \\mathit { \\Sigma } }", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 460, + 506, + 472 + ], + "score": 1.0, + "content": "D is", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 470, + 506, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 154, + 486 + ], + "score": 1.0, + "content": "replaced by", + "type": "text" + }, + { + "bbox": [ + 155, + 471, + 209, + 483 + ], + "score": 0.86, + "content": "\\mathbf { d } ^ { ( i ) } \\mathbf { R } \\mathbf { B } \\mathbf { O }", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 470, + 325, + 486 + ], + "score": 1.0, + "content": "(yielding RBO-MAML) and", + "type": "text" + }, + { + "bbox": [ + 325, + 471, + 393, + 483 + ], + "score": 0.39, + "content": "\\mathbf { d } ^ { ( i ) } \\bar { \\mathbf { A } } \\mathbf { S } \\mathbf { E } \\mathbf { B } \\mathbf { O }", + "type": "inline_equation" + }, + { + "bbox": [ + 394, + 470, + 506, + 486 + ], + "score": 1.0, + "content": "(yielding ASEBO-MAML)", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 483, + 159, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 159, + 497 + ], + "score": 1.0, + "content": "respectively.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 448, + 506, + 497 + ] + }, + { + "type": "image", + "bbox": [ + 125, + 530, + 483, + 665 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 159, + 516, + 451, + 528 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 158, + 516, + 452, + 531 + ], + "spans": [ + { + "bbox": [ + 158, + 516, + 452, + 531 + ], + "score": 1.0, + "content": "Figure A3: RBO-MAML and ASEBO-MAML compared to ES-MAML.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 30 + }, + { + "type": "image_body", + "bbox": [ + 125, + 530, + 483, + 665 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 125, + 530, + 483, + 665 + ], + "spans": [ + { + "bbox": [ + 125, + 530, + 483, + 665 + ], + "score": 0.969, + "type": "image", + "image_path": "944b249f7efd56cf286c8da0000c96bb66703e8e8172ad29e3928cfdcb7cea57.jpg" + } + ] + } + ], + "index": 32, + "virtual_lines": [ + { + "bbox": [ + 125, + 530, + 483, + 575.0 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 125, + 575.0, + 483, + 620.0 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 125, + 620.0, + 483, + 665.0 + ], + "spans": [], + "index": 33 + } + ] + } + ], + "index": 31.0 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "score": 1.0, + "content": "On the left plot, we test for noise robustness on the Forward-Backward Swimmer MAML task, com-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "paring standard ES-MAML (Algorithm 3) to RBO-MAML. To simulate noisy data, we randomly", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 708, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 138, + 723 + ], + "score": 1.0, + "content": "corrupt", + "type": "text" + }, + { + "bbox": [ + 138, + 709, + 158, + 720 + ], + "score": 0.88, + "content": "2 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 708, + 219, + 723 + ], + "score": 1.0, + "content": "of the queries", + "type": "text" + }, + { + "bbox": [ + 219, + 709, + 269, + 722 + ], + "score": 0.91, + "content": "f ^ { T } ( { \\overline { { \\theta } } } + \\sigma g )", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 708, + 437, + 723 + ], + "score": 1.0, + "content": "used to estimate the adaptation operator", + "type": "text" + }, + { + "bbox": [ + 437, + 710, + 470, + 722 + ], + "score": 0.93, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 708, + 506, + 723 + ], + "score": 1.0, + "content": "with an", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "enormous additive noise. This is the same type of corruption used in (Choromanski et al., 2019c).", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 687, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "Interestingly, RBO does not appear to be more robust against noise than the standard MC estimator,", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 438, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 438, + 106 + ], + "score": 1.0, + "content": "which suggests that the original ES-MAML has some inherent robustness to noise.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 107, + 110, + 505, + 165 + ], + "lines": [ + { + "bbox": [ + 106, + 110, + 505, + 122 + ], + "spans": [ + { + "bbox": [ + 106, + 110, + 505, + 122 + ], + "score": 1.0, + "content": "On the right plot, we compare ASEBO-MAML to ES-MAML on the Goal-Velocity HalfCheetah", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 121, + 505, + 133 + ], + "spans": [ + { + "bbox": [ + 106, + 121, + 167, + 133 + ], + "score": 1.0, + "content": "task in the low-", + "type": "text" + }, + { + "bbox": [ + 168, + 122, + 178, + 131 + ], + "score": 0.78, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 178, + 121, + 505, + 133 + ], + "score": 1.0, + "content": "setting. We found that when measured in iterations, ASEBO-MAML outperforms", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 132, + 505, + 144 + ], + "spans": [ + { + "bbox": [ + 106, + 132, + 505, + 144 + ], + "score": 1.0, + "content": "ES-MAML. However, ASEBO requires additional linear algebra operations and thus uses signif-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 143, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 143, + 505, + 156 + ], + "score": 1.0, + "content": "icantly more wall-clock time (not shown in plot) per iteration, so if measured by real time, then", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 154, + 235, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 154, + 235, + 167 + ], + "score": 1.0, + "content": "ES-MAML was more effective.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4 + }, + { + "type": "title", + "bbox": [ + 108, + 181, + 333, + 195 + ], + "lines": [ + { + "bbox": [ + 106, + 181, + 334, + 197 + ], + "spans": [ + { + "bbox": [ + 106, + 181, + 334, + 197 + ], + "score": 1.0, + "content": "A.4 NAVIGATION-2D EXPLORATION TASK", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 206, + 505, + 306 + ], + "lines": [ + { + "bbox": [ + 106, + 207, + 505, + 219 + ], + "spans": [ + { + "bbox": [ + 106, + 207, + 154, + 219 + ], + "score": 1.0, + "content": "Navigation-", + "type": "text" + }, + { + "bbox": [ + 154, + 207, + 168, + 217 + ], + "score": 0.49, + "content": "2 D", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 207, + 505, + 219 + ], + "score": 1.0, + "content": "(Finn et al., 2017) is a classic environment where the agent must explore to adapt", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 218, + 505, + 230 + ], + "spans": [ + { + "bbox": [ + 105, + 218, + 505, + 230 + ], + "score": 1.0, + "content": "to the task. The agent is represented by a point on a 2D square, and at each time step, receives", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 229, + 506, + 242 + ], + "spans": [ + { + "bbox": [ + 105, + 229, + 506, + 242 + ], + "score": 1.0, + "content": "reward equal to its distance from a given target point on the square. Note that unlike the four corners", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 240, + 505, + 253 + ], + "spans": [ + { + "bbox": [ + 105, + 240, + 505, + 253 + ], + "score": 1.0, + "content": "and six circles tasks, the reward for Navigation-2D is dense. We visualize the differing exploration", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 250, + 505, + 264 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 505, + 264 + ], + "score": 1.0, + "content": "strategies learned by PG-MAML and ES-MAML in Figure A4. Notice that PG-MAML makes many", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 262, + 505, + 274 + ], + "spans": [ + { + "bbox": [ + 106, + 262, + 505, + 274 + ], + "score": 1.0, + "content": "tiny movements in multiple directions to ‘triangulate’ the target location using the differences in", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 273, + 505, + 285 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 505, + 285 + ], + "score": 1.0, + "content": "reward for different state-action pairs. On the other hand, ES-MAML learns a meta-policy such that", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 283, + 506, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 283, + 506, + 297 + ], + "score": 1.0, + "content": "each perturbation of the meta-policy causes the agent to move in a different direction (represented", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 294, + 459, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 459, + 307 + ], + "score": 1.0, + "content": "by red paths), so it can determine the target location from the total rewards of each path.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 12 + }, + { + "type": "image", + "bbox": [ + 126, + 357, + 485, + 536 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 106, + 326, + 504, + 349 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 326, + 504, + 339 + ], + "spans": [ + { + "bbox": [ + 106, + 326, + 504, + 339 + ], + "score": 1.0, + "content": "Figure A4: Comparing the exploration behavior of PG-MAML and ES-MAML on the Navigation-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 337, + 318, + 350 + ], + "spans": [ + { + "bbox": [ + 106, + 337, + 174, + 350 + ], + "score": 1.0, + "content": "2D task. We use", + "type": "text" + }, + { + "bbox": [ + 174, + 338, + 208, + 348 + ], + "score": 0.89, + "content": "K = 2 0", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 337, + 318, + 350 + ], + "score": 1.0, + "content": "queries for each algorithm.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "image_body", + "bbox": [ + 126, + 357, + 485, + 536 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 126, + 357, + 485, + 536 + ], + "spans": [ + { + "bbox": [ + 126, + 357, + 485, + 536 + ], + "score": 0.963, + "type": "image", + "image_path": "7743efe9624bcdee1f67cc14ff0db5797eb8968938a97287b4350d5846884cdd.jpg" + } + ] + } + ], + "index": 20, + "virtual_lines": [ + { + "bbox": [ + 126, + 357, + 485, + 416.6666666666667 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 126, + 416.6666666666667, + 485, + 476.33333333333337 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 126, + 476.33333333333337, + 485, + 536.0 + ], + "spans": [], + "index": 21 + } + ] + } + ], + "index": 18.75 + } + ], + "page_idx": 15, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "16", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "Interestingly, RBO does not appear to be more robust against noise than the standard MC estimator,", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 438, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 438, + 106 + ], + "score": 1.0, + "content": "which suggests that the original ES-MAML has some inherent robustness to noise.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 105, + 81, + 505, + 106 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 110, + 505, + 165 + ], + "lines": [ + { + "bbox": [ + 106, + 110, + 505, + 122 + ], + "spans": [ + { + "bbox": [ + 106, + 110, + 505, + 122 + ], + "score": 1.0, + "content": "On the right plot, we compare ASEBO-MAML to ES-MAML on the Goal-Velocity HalfCheetah", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 121, + 505, + 133 + ], + "spans": [ + { + "bbox": [ + 106, + 121, + 167, + 133 + ], + "score": 1.0, + "content": "task in the low-", + "type": "text" + }, + { + "bbox": [ + 168, + 122, + 178, + 131 + ], + "score": 0.78, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 178, + 121, + 505, + 133 + ], + "score": 1.0, + "content": "setting. We found that when measured in iterations, ASEBO-MAML outperforms", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 132, + 505, + 144 + ], + "spans": [ + { + "bbox": [ + 106, + 132, + 505, + 144 + ], + "score": 1.0, + "content": "ES-MAML. However, ASEBO requires additional linear algebra operations and thus uses signif-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 143, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 143, + 505, + 156 + ], + "score": 1.0, + "content": "icantly more wall-clock time (not shown in plot) per iteration, so if measured by real time, then", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 154, + 235, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 154, + 235, + 167 + ], + "score": 1.0, + "content": "ES-MAML was more effective.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4, + "bbox_fs": [ + 105, + 110, + 505, + 167 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 181, + 333, + 195 + ], + "lines": [ + { + "bbox": [ + 106, + 181, + 334, + 197 + ], + "spans": [ + { + "bbox": [ + 106, + 181, + 334, + 197 + ], + "score": 1.0, + "content": "A.4 NAVIGATION-2D EXPLORATION TASK", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 206, + 505, + 306 + ], + "lines": [ + { + "bbox": [ + 106, + 207, + 505, + 219 + ], + "spans": [ + { + "bbox": [ + 106, + 207, + 154, + 219 + ], + "score": 1.0, + "content": "Navigation-", + "type": "text" + }, + { + "bbox": [ + 154, + 207, + 168, + 217 + ], + "score": 0.49, + "content": "2 D", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 207, + 505, + 219 + ], + "score": 1.0, + "content": "(Finn et al., 2017) is a classic environment where the agent must explore to adapt", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 218, + 505, + 230 + ], + "spans": [ + { + "bbox": [ + 105, + 218, + 505, + 230 + ], + "score": 1.0, + "content": "to the task. The agent is represented by a point on a 2D square, and at each time step, receives", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 229, + 506, + 242 + ], + "spans": [ + { + "bbox": [ + 105, + 229, + 506, + 242 + ], + "score": 1.0, + "content": "reward equal to its distance from a given target point on the square. Note that unlike the four corners", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 240, + 505, + 253 + ], + "spans": [ + { + "bbox": [ + 105, + 240, + 505, + 253 + ], + "score": 1.0, + "content": "and six circles tasks, the reward for Navigation-2D is dense. We visualize the differing exploration", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 250, + 505, + 264 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 505, + 264 + ], + "score": 1.0, + "content": "strategies learned by PG-MAML and ES-MAML in Figure A4. Notice that PG-MAML makes many", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 262, + 505, + 274 + ], + "spans": [ + { + "bbox": [ + 106, + 262, + 505, + 274 + ], + "score": 1.0, + "content": "tiny movements in multiple directions to ‘triangulate’ the target location using the differences in", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 273, + 505, + 285 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 505, + 285 + ], + "score": 1.0, + "content": "reward for different state-action pairs. On the other hand, ES-MAML learns a meta-policy such that", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 283, + 506, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 283, + 506, + 297 + ], + "score": 1.0, + "content": "each perturbation of the meta-policy causes the agent to move in a different direction (represented", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 294, + 459, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 459, + 307 + ], + "score": 1.0, + "content": "by red paths), so it can determine the target location from the total rewards of each path.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 207, + 506, + 307 + ] + }, + { + "type": "image", + "bbox": [ + 126, + 357, + 485, + 536 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 106, + 326, + 504, + 349 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 326, + 504, + 339 + ], + "spans": [ + { + "bbox": [ + 106, + 326, + 504, + 339 + ], + "score": 1.0, + "content": "Figure A4: Comparing the exploration behavior of PG-MAML and ES-MAML on the Navigation-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 337, + 318, + 350 + ], + "spans": [ + { + "bbox": [ + 106, + 337, + 174, + 350 + ], + "score": 1.0, + "content": "2D task. We use", + "type": "text" + }, + { + "bbox": [ + 174, + 338, + 208, + 348 + ], + "score": 0.89, + "content": "K = 2 0", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 337, + 318, + 350 + ], + "score": 1.0, + "content": "queries for each algorithm.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "image_body", + "bbox": [ + 126, + 357, + 485, + 536 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 126, + 357, + 485, + 536 + ], + "spans": [ + { + "bbox": [ + 126, + 357, + 485, + 536 + ], + "score": 0.963, + "type": "image", + "image_path": "7743efe9624bcdee1f67cc14ff0db5797eb8968938a97287b4350d5846884cdd.jpg" + } + ] + } + ], + "index": 20, + "virtual_lines": [ + { + "bbox": [ + 126, + 357, + 485, + 416.6666666666667 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 126, + 416.6666666666667, + 485, + 476.33333333333337 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 126, + 476.33333333333337, + 485, + 536.0 + ], + "spans": [], + "index": 21 + } + ] + } + ], + "index": 18.75 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 81, + 296, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 79, + 297, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 79, + 297, + 96 + ], + "score": 1.0, + "content": "A.5 PG-MAML RL BENCHMARKS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 105, + 505, + 139 + ], + "lines": [ + { + "bbox": [ + 105, + 105, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 505, + 119 + ], + "score": 1.0, + "content": "In Figure A5, we compare ES-MAML and PG-MAML on the Forward-Backward and Goal-Velocity", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 116, + 504, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 116, + 423, + 128 + ], + "score": 1.0, + "content": "tasks for HalfCheetah, Swimmer, Walker2d, and Ant, using the same values of", + "type": "text" + }, + { + "bbox": [ + 423, + 117, + 433, + 127 + ], + "score": 0.79, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 116, + 504, + 128 + ], + "score": 1.0, + "content": "that were used in", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 128, + 293, + 140 + ], + "spans": [ + { + "bbox": [ + 106, + 128, + 293, + 140 + ], + "score": 1.0, + "content": "the original experiments of (Finn et al., 2017).", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2 + }, + { + "type": "image", + "bbox": [ + 108, + 180, + 503, + 395 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 107, + 157, + 504, + 180 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 156, + 505, + 171 + ], + "spans": [ + { + "bbox": [ + 105, + 156, + 424, + 171 + ], + "score": 1.0, + "content": "Figure A5: Comparisons between ES-MAML and PG-MAML using the queries", + "type": "text" + }, + { + "bbox": [ + 425, + 158, + 435, + 168 + ], + "score": 0.78, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 436, + 156, + 505, + 171 + ], + "score": 1.0, + "content": "from (Finn et al.,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 104, + 166, + 136, + 183 + ], + "spans": [ + { + "bbox": [ + 104, + 166, + 136, + 183 + ], + "score": 1.0, + "content": "2017).", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "image_body", + "bbox": [ + 108, + 180, + 503, + 395 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 180, + 503, + 395 + ], + "spans": [ + { + "bbox": [ + 108, + 180, + 503, + 395 + ], + "score": 0.971, + "type": "image", + "image_path": "e3b5fc6f1921e17a3ab454ce483df00bbbc16057bfcd9c0bceb1d395ca2c2664.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 108, + 180, + 503, + 251.66666666666669 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 108, + 251.66666666666669, + 503, + 323.33333333333337 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 108, + 323.33333333333337, + 503, + 395.00000000000006 + ], + "spans": [], + "index": 8 + } + ] + } + ], + "index": 5.75 + }, + { + "type": "title", + "bbox": [ + 107, + 422, + 357, + 435 + ], + "lines": [ + { + "bbox": [ + 106, + 421, + 358, + 437 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 358, + 437 + ], + "score": 1.0, + "content": "A.6 REGRESSION AND SUPERVISED LEARNING", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 106, + 446, + 505, + 491 + ], + "lines": [ + { + "bbox": [ + 105, + 446, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 505, + 459 + ], + "score": 1.0, + "content": "MAML has also been applied to supervised learning. We demonstrate ES-MAML on sine regression", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 458, + 505, + 470 + ], + "spans": [ + { + "bbox": [ + 106, + 458, + 326, + 470 + ], + "score": 1.0, + "content": "(Finn et al., 2017), where the task is to fit a sine curve", + "type": "text" + }, + { + "bbox": [ + 327, + 458, + 334, + 469 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 458, + 505, + 470 + ], + "score": 1.0, + "content": "with unknown amplitude and phase given", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 469, + 505, + 481 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 138, + 481 + ], + "score": 1.0, + "content": "a set of", + "type": "text" + }, + { + "bbox": [ + 138, + 469, + 149, + 479 + ], + "score": 0.82, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 149, + 469, + 172, + 481 + ], + "score": 1.0, + "content": "pairs", + "type": "text" + }, + { + "bbox": [ + 172, + 469, + 216, + 481 + ], + "score": 0.93, + "content": "( x _ { i } , f ( x _ { i } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 469, + 505, + 481 + ], + "score": 1.0, + "content": ". The meta-policy must be able to learn that all of tasks have a common", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 104, + 479, + 489, + 493 + ], + "spans": [ + { + "bbox": [ + 104, + 479, + 474, + 493 + ], + "score": 1.0, + "content": "periodic nature, so that it can correctly adapt to an unknown sine curve outside of the points", + "type": "text" + }, + { + "bbox": [ + 475, + 482, + 485, + 491 + ], + "score": 0.85, + "content": "x _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 485, + 479, + 489, + 493 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 106, + 496, + 505, + 578 + ], + "lines": [ + { + "bbox": [ + 105, + 495, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 447, + 509 + ], + "score": 1.0, + "content": "For regression, the loss is the mean-squared error (MSE) between the adapted policy", + "type": "text" + }, + { + "bbox": [ + 447, + 496, + 472, + 508 + ], + "score": 0.9, + "content": "\\pi _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 472, + 495, + 506, + 509 + ], + "score": 1.0, + "content": "and the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 101, + 502, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 101, + 502, + 148, + 528 + ], + "score": 1.0, + "content": "true curve", + "type": "text" + }, + { + "bbox": [ + 149, + 509, + 168, + 522 + ], + "score": 0.91, + "content": "f ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 502, + 252, + 528 + ], + "score": 1.0, + "content": ". Given data samples", + "type": "text" + }, + { + "bbox": [ + 252, + 509, + 316, + 522 + ], + "score": 0.93, + "content": "\\{ ( x _ { i } , f ( x _ { i } ) \\} _ { i = 1 } ^ { K }", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 502, + 400, + 528 + ], + "score": 1.0, + "content": ", the empirical loss is", + "type": "text" + }, + { + "bbox": [ + 400, + 508, + 505, + 523 + ], + "score": 0.91, + "content": "\\begin{array} { r } { L ( \\theta ) = \\frac { 1 } { K } \\sum _ { i = 1 } ^ { K } ( f ( x _ { i } ) - } \\end{array}", + "type": "inline_equation" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 520, + 506, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 522, + 142, + 534 + ], + "score": 0.92, + "content": "\\pi _ { \\boldsymbol { \\theta } } ( x _ { i } ) ) ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 143, + 520, + 419, + 536 + ], + "score": 1.0, + "content": ". Note that unlike in reinforcement learning, we can exactly compute", + "type": "text" + }, + { + "bbox": [ + 419, + 523, + 447, + 534 + ], + "score": 0.9, + "content": "\\nabla L ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 520, + 506, + 536 + ], + "score": 1.0, + "content": "; for deep net-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 533, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 533, + 505, + 545 + ], + "score": 1.0, + "content": "works, this is by automatic differentiation. Thus, we opt to use Tensorflow to compute the adaptation", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 543, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 143, + 558 + ], + "score": 1.0, + "content": "operator", + "type": "text" + }, + { + "bbox": [ + 143, + 545, + 176, + 556 + ], + "score": 0.92, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 543, + 505, + 558 + ], + "score": 1.0, + "content": "in Algorithm 3. This is in accordance with the general principle that when gra-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 555, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 106, + 555, + 505, + 568 + ], + "score": 1.0, + "content": "dients are available, it is more efficient to use the gradient than to approximate it by a zero-order", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 566, + 262, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 262, + 579 + ], + "score": 1.0, + "content": "method (Nesterov & Spokoiny, 2017).", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 582, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 106, + 582, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 582, + 381, + 595 + ], + "score": 1.0, + "content": "We show several results in Figure A6. The adaptation step size is", + "type": "text" + }, + { + "bbox": [ + 381, + 583, + 423, + 594 + ], + "score": 0.89, + "content": "\\alpha = 0 . 0 1", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 582, + 505, + 595 + ], + "score": 1.0, + "content": ", which is the same", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 594, + 506, + 607 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 506, + 607 + ], + "score": 1.0, + "content": "as in (Finn et al., 2017). For comparison, (Finn et al., 2017) reports that PG-MAML can obtain a", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 605, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 136, + 617 + ], + "score": 1.0, + "content": "loss of", + "type": "text" + }, + { + "bbox": [ + 136, + 605, + 161, + 615 + ], + "score": 0.84, + "content": "\\approx 0 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 605, + 285, + 617 + ], + "score": 1.0, + "content": "after one adaptation step with", + "type": "text" + }, + { + "bbox": [ + 285, + 605, + 315, + 615 + ], + "score": 0.89, + "content": "K = 5", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 605, + 505, + 617 + ], + "score": 1.0, + "content": ", though it is not specified how many iterations", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 616, + 504, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 504, + 628 + ], + "score": 1.0, + "content": "the meta-policy was trained for. ES-MAML approaches the same level of performance, though the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "number of training iterations required is higher than for the RL tasks, and surprisingly high for what", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 638, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 505, + 651 + ], + "score": 1.0, + "content": "appears to be a simpler problem. This is likely again a reflection of the fact that for problems such", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 649, + 439, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 439, + 661 + ], + "score": 1.0, + "content": "as regression where the gradients are available, it is more efficient to use gradients.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 666, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 665, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 665, + 483, + 678 + ], + "score": 1.0, + "content": "As an aside, this leads to a related question of the correct interpretation of the query number", + "type": "text" + }, + { + "bbox": [ + 483, + 666, + 493, + 676 + ], + "score": 0.8, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 493, + 665, + 505, + 678 + ], + "score": 1.0, + "content": "in", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 104, + 675, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 104, + 675, + 415, + 690 + ], + "score": 1.0, + "content": "the supervised setting. There is a distinction between obtaining a data sample", + "type": "text" + }, + { + "bbox": [ + 415, + 677, + 459, + 689 + ], + "score": 0.93, + "content": "( x _ { i } , f ( x _ { i } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 460, + 675, + 506, + 690 + ], + "score": 1.0, + "content": ", and doing", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 104, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "a computation (such as a gradient) using that sample. If the main bottleneck is collecting the data", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 107, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 107, + 699, + 158, + 711 + ], + "score": 0.92, + "content": "\\{ ( x _ { i } , f ( x _ { i } ) \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 158, + 699, + 505, + 712 + ], + "score": 1.0, + "content": ", then we may be satisfied with any algorithm that performs any number of operations", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 104, + 708, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 104, + 708, + 251, + 724 + ], + "score": 1.0, + "content": "on the data, as long as it uses only", + "type": "text" + }, + { + "bbox": [ + 252, + 711, + 262, + 720 + ], + "score": 0.81, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 708, + 506, + 724 + ], + "score": 1.0, + "content": "samples. On the other hand, in the (on-policy) RL setting,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 721, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 407, + 733 + ], + "score": 1.0, + "content": "samples cannot typically be ‘re-used’ to the same extent, because rollouts", + "type": "text" + }, + { + "bbox": [ + 408, + 723, + 415, + 730 + ], + "score": 0.76, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 721, + 505, + 733 + ], + "score": 1.0, + "content": "sampled with a given", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 30.5 + } + ], + "page_idx": 16, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "17", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 81, + 296, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 79, + 297, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 79, + 297, + 96 + ], + "score": 1.0, + "content": "A.5 PG-MAML RL BENCHMARKS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 105, + 505, + 139 + ], + "lines": [ + { + "bbox": [ + 105, + 105, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 505, + 119 + ], + "score": 1.0, + "content": "In Figure A5, we compare ES-MAML and PG-MAML on the Forward-Backward and Goal-Velocity", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 116, + 504, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 116, + 423, + 128 + ], + "score": 1.0, + "content": "tasks for HalfCheetah, Swimmer, Walker2d, and Ant, using the same values of", + "type": "text" + }, + { + "bbox": [ + 423, + 117, + 433, + 127 + ], + "score": 0.79, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 116, + 504, + 128 + ], + "score": 1.0, + "content": "that were used in", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 128, + 293, + 140 + ], + "spans": [ + { + "bbox": [ + 106, + 128, + 293, + 140 + ], + "score": 1.0, + "content": "the original experiments of (Finn et al., 2017).", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2, + "bbox_fs": [ + 105, + 105, + 505, + 140 + ] + }, + { + "type": "image", + "bbox": [ + 108, + 180, + 503, + 395 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 107, + 157, + 504, + 180 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 156, + 505, + 171 + ], + "spans": [ + { + "bbox": [ + 105, + 156, + 424, + 171 + ], + "score": 1.0, + "content": "Figure A5: Comparisons between ES-MAML and PG-MAML using the queries", + "type": "text" + }, + { + "bbox": [ + 425, + 158, + 435, + 168 + ], + "score": 0.78, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 436, + 156, + 505, + 171 + ], + "score": 1.0, + "content": "from (Finn et al.,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 104, + 166, + 136, + 183 + ], + "spans": [ + { + "bbox": [ + 104, + 166, + 136, + 183 + ], + "score": 1.0, + "content": "2017).", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "image_body", + "bbox": [ + 108, + 180, + 503, + 395 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 180, + 503, + 395 + ], + "spans": [ + { + "bbox": [ + 108, + 180, + 503, + 395 + ], + "score": 0.971, + "type": "image", + "image_path": "e3b5fc6f1921e17a3ab454ce483df00bbbc16057bfcd9c0bceb1d395ca2c2664.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 108, + 180, + 503, + 251.66666666666669 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 108, + 251.66666666666669, + 503, + 323.33333333333337 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 108, + 323.33333333333337, + 503, + 395.00000000000006 + ], + "spans": [], + "index": 8 + } + ] + } + ], + "index": 5.75 + }, + { + "type": "title", + "bbox": [ + 107, + 422, + 357, + 435 + ], + "lines": [ + { + "bbox": [ + 106, + 421, + 358, + 437 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 358, + 437 + ], + "score": 1.0, + "content": "A.6 REGRESSION AND SUPERVISED LEARNING", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 106, + 446, + 505, + 491 + ], + "lines": [ + { + "bbox": [ + 105, + 446, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 505, + 459 + ], + "score": 1.0, + "content": "MAML has also been applied to supervised learning. We demonstrate ES-MAML on sine regression", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 458, + 505, + 470 + ], + "spans": [ + { + "bbox": [ + 106, + 458, + 326, + 470 + ], + "score": 1.0, + "content": "(Finn et al., 2017), where the task is to fit a sine curve", + "type": "text" + }, + { + "bbox": [ + 327, + 458, + 334, + 469 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 458, + 505, + 470 + ], + "score": 1.0, + "content": "with unknown amplitude and phase given", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 469, + 505, + 481 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 138, + 481 + ], + "score": 1.0, + "content": "a set of", + "type": "text" + }, + { + "bbox": [ + 138, + 469, + 149, + 479 + ], + "score": 0.82, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 149, + 469, + 172, + 481 + ], + "score": 1.0, + "content": "pairs", + "type": "text" + }, + { + "bbox": [ + 172, + 469, + 216, + 481 + ], + "score": 0.93, + "content": "( x _ { i } , f ( x _ { i } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 469, + 505, + 481 + ], + "score": 1.0, + "content": ". The meta-policy must be able to learn that all of tasks have a common", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 104, + 479, + 489, + 493 + ], + "spans": [ + { + "bbox": [ + 104, + 479, + 474, + 493 + ], + "score": 1.0, + "content": "periodic nature, so that it can correctly adapt to an unknown sine curve outside of the points", + "type": "text" + }, + { + "bbox": [ + 475, + 482, + 485, + 491 + ], + "score": 0.85, + "content": "x _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 485, + 479, + 489, + 493 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11.5, + "bbox_fs": [ + 104, + 446, + 505, + 493 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 496, + 505, + 578 + ], + "lines": [ + { + "bbox": [ + 105, + 495, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 447, + 509 + ], + "score": 1.0, + "content": "For regression, the loss is the mean-squared error (MSE) between the adapted policy", + "type": "text" + }, + { + "bbox": [ + 447, + 496, + 472, + 508 + ], + "score": 0.9, + "content": "\\pi _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 472, + 495, + 506, + 509 + ], + "score": 1.0, + "content": "and the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 101, + 502, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 101, + 502, + 148, + 528 + ], + "score": 1.0, + "content": "true curve", + "type": "text" + }, + { + "bbox": [ + 149, + 509, + 168, + 522 + ], + "score": 0.91, + "content": "f ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 502, + 252, + 528 + ], + "score": 1.0, + "content": ". Given data samples", + "type": "text" + }, + { + "bbox": [ + 252, + 509, + 316, + 522 + ], + "score": 0.93, + "content": "\\{ ( x _ { i } , f ( x _ { i } ) \\} _ { i = 1 } ^ { K }", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 502, + 400, + 528 + ], + "score": 1.0, + "content": ", the empirical loss is", + "type": "text" + }, + { + "bbox": [ + 400, + 508, + 505, + 523 + ], + "score": 0.91, + "content": "\\begin{array} { r } { L ( \\theta ) = \\frac { 1 } { K } \\sum _ { i = 1 } ^ { K } ( f ( x _ { i } ) - } \\end{array}", + "type": "inline_equation" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 520, + 506, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 522, + 142, + 534 + ], + "score": 0.92, + "content": "\\pi _ { \\boldsymbol { \\theta } } ( x _ { i } ) ) ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 143, + 520, + 419, + 536 + ], + "score": 1.0, + "content": ". Note that unlike in reinforcement learning, we can exactly compute", + "type": "text" + }, + { + "bbox": [ + 419, + 523, + 447, + 534 + ], + "score": 0.9, + "content": "\\nabla L ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 520, + 506, + 536 + ], + "score": 1.0, + "content": "; for deep net-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 533, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 533, + 505, + 545 + ], + "score": 1.0, + "content": "works, this is by automatic differentiation. Thus, we opt to use Tensorflow to compute the adaptation", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 543, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 143, + 558 + ], + "score": 1.0, + "content": "operator", + "type": "text" + }, + { + "bbox": [ + 143, + 545, + 176, + 556 + ], + "score": 0.92, + "content": "U ( \\theta , T )", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 543, + 505, + 558 + ], + "score": 1.0, + "content": "in Algorithm 3. This is in accordance with the general principle that when gra-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 555, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 106, + 555, + 505, + 568 + ], + "score": 1.0, + "content": "dients are available, it is more efficient to use the gradient than to approximate it by a zero-order", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 566, + 262, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 262, + 579 + ], + "score": 1.0, + "content": "method (Nesterov & Spokoiny, 2017).", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17, + "bbox_fs": [ + 101, + 495, + 506, + 579 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 582, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 106, + 582, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 582, + 381, + 595 + ], + "score": 1.0, + "content": "We show several results in Figure A6. The adaptation step size is", + "type": "text" + }, + { + "bbox": [ + 381, + 583, + 423, + 594 + ], + "score": 0.89, + "content": "\\alpha = 0 . 0 1", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 582, + 505, + 595 + ], + "score": 1.0, + "content": ", which is the same", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 594, + 506, + 607 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 506, + 607 + ], + "score": 1.0, + "content": "as in (Finn et al., 2017). For comparison, (Finn et al., 2017) reports that PG-MAML can obtain a", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 605, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 136, + 617 + ], + "score": 1.0, + "content": "loss of", + "type": "text" + }, + { + "bbox": [ + 136, + 605, + 161, + 615 + ], + "score": 0.84, + "content": "\\approx 0 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 605, + 285, + 617 + ], + "score": 1.0, + "content": "after one adaptation step with", + "type": "text" + }, + { + "bbox": [ + 285, + 605, + 315, + 615 + ], + "score": 0.89, + "content": "K = 5", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 605, + 505, + 617 + ], + "score": 1.0, + "content": ", though it is not specified how many iterations", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 616, + 504, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 504, + 628 + ], + "score": 1.0, + "content": "the meta-policy was trained for. ES-MAML approaches the same level of performance, though the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "number of training iterations required is higher than for the RL tasks, and surprisingly high for what", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 638, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 505, + 651 + ], + "score": 1.0, + "content": "appears to be a simpler problem. This is likely again a reflection of the fact that for problems such", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 649, + 439, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 439, + 661 + ], + "score": 1.0, + "content": "as regression where the gradients are available, it is more efficient to use gradients.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24, + "bbox_fs": [ + 105, + 582, + 506, + 661 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 666, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 665, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 665, + 483, + 678 + ], + "score": 1.0, + "content": "As an aside, this leads to a related question of the correct interpretation of the query number", + "type": "text" + }, + { + "bbox": [ + 483, + 666, + 493, + 676 + ], + "score": 0.8, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 493, + 665, + 505, + 678 + ], + "score": 1.0, + "content": "in", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 104, + 675, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 104, + 675, + 415, + 690 + ], + "score": 1.0, + "content": "the supervised setting. There is a distinction between obtaining a data sample", + "type": "text" + }, + { + "bbox": [ + 415, + 677, + 459, + 689 + ], + "score": 0.93, + "content": "( x _ { i } , f ( x _ { i } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 460, + 675, + 506, + 690 + ], + "score": 1.0, + "content": ", and doing", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 104, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "a computation (such as a gradient) using that sample. If the main bottleneck is collecting the data", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 107, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 107, + 699, + 158, + 711 + ], + "score": 0.92, + "content": "\\{ ( x _ { i } , f ( x _ { i } ) \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 158, + 699, + 505, + 712 + ], + "score": 1.0, + "content": ", then we may be satisfied with any algorithm that performs any number of operations", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 104, + 708, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 104, + 708, + 251, + 724 + ], + "score": 1.0, + "content": "on the data, as long as it uses only", + "type": "text" + }, + { + "bbox": [ + 252, + 711, + 262, + 720 + ], + "score": 0.81, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 708, + 506, + 724 + ], + "score": 1.0, + "content": "samples. On the other hand, in the (on-policy) RL setting,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 721, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 407, + 733 + ], + "score": 1.0, + "content": "samples cannot typically be ‘re-used’ to the same extent, because rollouts", + "type": "text" + }, + { + "bbox": [ + 408, + 723, + 415, + 730 + ], + "score": 0.76, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 721, + 505, + 733 + ], + "score": 1.0, + "content": "sampled with a given", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 271, + 133, + 284 + ], + "score": 1.0, + "content": "policy", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 133, + 274, + 145, + 283 + ], + "score": 0.84, + "content": "\\pi _ { \\theta }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 145, + 271, + 271, + 284 + ], + "score": 1.0, + "content": "follow an unknown distribution", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 272, + 272, + 301, + 284 + ], + "score": 0.93, + "content": "{ \\mathcal { P } } ( \\tau | \\theta )", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 302, + 271, + 469, + 284 + ], + "score": 1.0, + "content": "which reduces their usefulness away from", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 470, + 272, + 476, + 282 + ], + "score": 0.59, + "content": "\\theta", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 476, + 271, + 505, + 284 + ], + "score": 1.0, + "content": ". Thus,", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 283, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 106, + 283, + 505, + 295 + ], + "score": 1.0, + "content": "the corresponding notion to rollouts in the SL setting would be the number of backpropagations (for", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 104, + 293, + 506, + 307 + ], + "spans": [ + { + "bbox": [ + 104, + 293, + 506, + 307 + ], + "score": 1.0, + "content": "PG-MAML) or perturbations (for ES-MAML), but clearly these have different relative costs than", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 305, + 208, + 317 + ], + "spans": [ + { + "bbox": [ + 106, + 305, + 208, + 317 + ], + "score": 1.0, + "content": "doing simulations in RL.", + "type": "text", + "cross_page": true + } + ], + "index": 8 + } + ], + "index": 30.5, + "bbox_fs": [ + 104, + 665, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 113, + 113, + 493, + 249 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 107, + 89, + 505, + 111 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 88, + 505, + 102 + ], + "spans": [ + { + "bbox": [ + 105, + 88, + 505, + 102 + ], + "score": 1.0, + "content": "Figure A6: The MSE of the adapted policy, for varying number of gradient steps and query number", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 107, + 99, + 258, + 113 + ], + "spans": [ + { + "bbox": [ + 107, + 101, + 117, + 110 + ], + "score": 0.64, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 99, + 258, + 113 + ], + "score": 1.0, + "content": ". Runs are averaged across 3 seeds.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "image_body", + "bbox": [ + 113, + 113, + 493, + 249 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 113, + 113, + 493, + 249 + ], + "spans": [ + { + "bbox": [ + 113, + 113, + 493, + 249 + ], + "score": 0.961, + "type": "image", + "image_path": "b90ce753a22a6b3ac6b1cd444b23d91872ae060a1fa15556ab4bbc9c766cbe11.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 113, + 113, + 493, + 158.33333333333334 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 113, + 158.33333333333334, + 493, + 203.66666666666669 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 113, + 203.66666666666669, + 493, + 249.00000000000003 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 1.75 + }, + { + "type": "text", + "bbox": [ + 106, + 271, + 506, + 316 + ], + "lines": [ + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 271, + 133, + 284 + ], + "score": 1.0, + "content": "policy", + "type": "text" + }, + { + "bbox": [ + 133, + 274, + 145, + 283 + ], + "score": 0.84, + "content": "\\pi _ { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 271, + 271, + 284 + ], + "score": 1.0, + "content": "follow an unknown distribution", + "type": "text" + }, + { + "bbox": [ + 272, + 272, + 301, + 284 + ], + "score": 0.93, + "content": "{ \\mathcal { P } } ( \\tau | \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 302, + 271, + 469, + 284 + ], + "score": 1.0, + "content": "which reduces their usefulness away from", + "type": "text" + }, + { + "bbox": [ + 470, + 272, + 476, + 282 + ], + "score": 0.59, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 271, + 505, + 284 + ], + "score": 1.0, + "content": ". Thus,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 283, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 106, + 283, + 505, + 295 + ], + "score": 1.0, + "content": "the corresponding notion to rollouts in the SL setting would be the number of backpropagations (for", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 104, + 293, + 506, + 307 + ], + "spans": [ + { + "bbox": [ + 104, + 293, + 506, + 307 + ], + "score": 1.0, + "content": "PG-MAML) or perturbations (for ES-MAML), but clearly these have different relative costs than", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 305, + 208, + 317 + ], + "spans": [ + { + "bbox": [ + 106, + 305, + 208, + 317 + ], + "score": 1.0, + "content": "doing simulations in RL.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6.5 + } + ], + "page_idx": 17, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 763 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 763 + ], + "score": 1.0, + "content": "18", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 113, + 113, + 493, + 249 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 107, + 89, + 505, + 111 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 88, + 505, + 102 + ], + "spans": [ + { + "bbox": [ + 105, + 88, + 505, + 102 + ], + "score": 1.0, + "content": "Figure A6: The MSE of the adapted policy, for varying number of gradient steps and query number", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 107, + 99, + 258, + 113 + ], + "spans": [ + { + "bbox": [ + 107, + 101, + 117, + 110 + ], + "score": 0.64, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 99, + 258, + 113 + ], + "score": 1.0, + "content": ". Runs are averaged across 3 seeds.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "image_body", + "bbox": [ + 113, + 113, + 493, + 249 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 113, + 113, + 493, + 249 + ], + "spans": [ + { + "bbox": [ + 113, + 113, + 493, + 249 + ], + "score": 0.961, + "type": "image", + "image_path": "b90ce753a22a6b3ac6b1cd444b23d91872ae060a1fa15556ab4bbc9c766cbe11.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 113, + 113, + 493, + 158.33333333333334 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 113, + 158.33333333333334, + 493, + 203.66666666666669 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 113, + 203.66666666666669, + 493, + 249.00000000000003 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 1.75 + }, + { + "type": "text", + "bbox": [ + 106, + 271, + 506, + 316 + ], + "lines": [], + "index": 6.5, + "bbox_fs": [ + 104, + 271, + 506, + 317 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 312, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 80, + 312, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 80, + 312, + 95 + ], + "score": 1.0, + "content": "A.7 HYPERPARAMETERS AND SETUPS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 108, + 106, + 212, + 118 + ], + "lines": [ + { + "bbox": [ + 106, + 105, + 213, + 119 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 213, + 119 + ], + "score": 1.0, + "content": "A.7.1 ENVIRONMENTS", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 126, + 505, + 171 + ], + "lines": [ + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 299, + 139 + ], + "score": 1.0, + "content": "Unless otherwise explicitly stated, we default to", + "type": "text" + }, + { + "bbox": [ + 300, + 127, + 334, + 137 + ], + "score": 0.9, + "content": "K = 2 0", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 126, + 383, + 139 + ], + "score": 1.0, + "content": "and horizon", + "type": "text" + }, + { + "bbox": [ + 383, + 127, + 409, + 137 + ], + "score": 0.82, + "content": "= 2 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 126, + 505, + 139 + ], + "score": 1.0, + "content": "for all RL experiments.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 137, + 505, + 149 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 505, + 149 + ], + "score": 1.0, + "content": "We also use the standard reward normalization in (Mania et al., 2018), and use a global state nor-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 149, + 505, + 160 + ], + "spans": [ + { + "bbox": [ + 106, + 149, + 505, + 160 + ], + "score": 1.0, + "content": "malization (i.e. the same mean, standard deviation normalization values for MDP states are shared", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 160, + 174, + 171 + ], + "spans": [ + { + "bbox": [ + 106, + 160, + 174, + 171 + ], + "score": 1.0, + "content": "across workers).", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 176, + 505, + 264 + ], + "lines": [ + { + "bbox": [ + 106, + 177, + 504, + 188 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 504, + 188 + ], + "score": 1.0, + "content": "For the Ant environments (Goal-Position Ant, Forward-Backward Ant), there are significant differ-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 188, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 505, + 200 + ], + "score": 1.0, + "content": "ences in weighting on the auxiliary rewards such as control costs, contact costs, and survival rewards", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 199, + 505, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 505, + 211 + ], + "score": 1.0, + "content": "across different previous work (e.g. those costs are downweighted in (Finn et al., 2017) whereas the", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 210, + 505, + 221 + ], + "spans": [ + { + "bbox": [ + 106, + 210, + 505, + 221 + ], + "score": 1.0, + "content": "coefficients are vanilla Gym weightings in (Liu et al., 2019)). These auxiliary rewards can lead to", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 220, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 505, + 234 + ], + "score": 1.0, + "content": "local minima, such as the agent staying stationary to collect the survival bonus which may be con-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 231, + 505, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 505, + 244 + ], + "score": 1.0, + "content": "fused with movement progress when presenting a training curve. To make sure the agent is explicitly", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 243, + 505, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 505, + 255 + ], + "score": 1.0, + "content": "performing the required task, we opted to remove such costs in our work and only present the main", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 253, + 359, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 359, + 266 + ], + "score": 1.0, + "content": "goal-distance cost and forward-movement reward respectively.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 107, + 270, + 504, + 293 + ], + "lines": [ + { + "bbox": [ + 105, + 268, + 505, + 283 + ], + "spans": [ + { + "bbox": [ + 105, + 268, + 505, + 283 + ], + "score": 1.0, + "content": "For the other environments, we used default weightings and rewards, since they do not change across", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 281, + 173, + 293 + ], + "spans": [ + { + "bbox": [ + 104, + 281, + 173, + 293 + ], + "score": 1.0, + "content": "previous works.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5 + }, + { + "type": "title", + "bbox": [ + 108, + 305, + 281, + 317 + ], + "lines": [ + { + "bbox": [ + 106, + 305, + 282, + 318 + ], + "spans": [ + { + "bbox": [ + 106, + 305, + 282, + 318 + ], + "score": 1.0, + "content": "A.7.2 ES-MAML HYPERPARAMETERS", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 326, + 504, + 349 + ], + "lines": [ + { + "bbox": [ + 105, + 325, + 505, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 123, + 339 + ], + "score": 1.0, + "content": "Let", + "type": "text" + }, + { + "bbox": [ + 123, + 327, + 134, + 336 + ], + "score": 0.81, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 134, + 325, + 505, + 339 + ], + "score": 1.0, + "content": "be the number of possible distinct tasks possible. We sample tasks without replacement,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 337, + 460, + 350 + ], + "spans": [ + { + "bbox": [ + 106, + 337, + 192, + 350 + ], + "score": 1.0, + "content": "which is important if", + "type": "text" + }, + { + "bbox": [ + 192, + 338, + 223, + 348 + ], + "score": 0.9, + "content": "N \\ll 5", + "type": "inline_equation" + }, + { + "bbox": [ + 223, + 337, + 460, + 350 + ], + "score": 1.0, + "content": ", as each worker performs adaptations on all possible tasks.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 107, + 354, + 393, + 366 + ], + "lines": [ + { + "bbox": [ + 105, + 352, + 394, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 394, + 369 + ], + "score": 1.0, + "content": "For standard ES-MAML (Algorithm 3), we used the following settings.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "table", + "bbox": [ + 155, + 376, + 455, + 528 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 155, + 376, + 455, + 528 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 155, + 376, + 455, + 528 + ], + "spans": [ + { + "bbox": [ + 155, + 376, + 455, + 528 + ], + "score": 0.985, + "html": "
SettingValue
(Total Workers,#Perturbations,#Current Evals)(300,150,150)
(Train SetSize,Task Batch Size,Test SetSize)(50,5,5) or (N,N,N)
Number of rolloutsper parameter1
NumberofPerturbationsperworker1
Outer-Loop Precision Parameter0.1
AdaptationPrecision Parameter0.1
Outer-Loop Step Size0.01
Adaptation Step Size (α)0.05
Hidden Layer Width32
ES Estimation TypeForward-FD
Reward NormalizationTrue
State NormalizationTrue
", + "type": "table", + "image_path": "190df265e3a35fe05a19895ef94cc0df21f3ab6223d2ed01cad0130a9f274663.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 155, + 376, + 455, + 426.6666666666667 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 155, + 426.6666666666667, + 455, + 477.33333333333337 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 155, + 477.33333333333337, + 455, + 528.0 + ], + "spans": [], + "index": 22 + } + ] + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 537, + 504, + 560 + ], + "lines": [ + { + "bbox": [ + 105, + 536, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 505, + 551 + ], + "score": 1.0, + "content": "For ES-MAML and PG-MAML, we took 3 seeded runs, using the default TRPO hyperparameters", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 548, + 214, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 548, + 214, + 559 + ], + "score": 1.0, + "content": "found in (Liu et al., 2019).", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5 + } + ], + "page_idx": 18, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 294, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 293, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 293, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2020", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "19", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 312, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 80, + 312, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 80, + 312, + 95 + ], + "score": 1.0, + "content": "A.7 HYPERPARAMETERS AND SETUPS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 108, + 106, + 212, + 118 + ], + "lines": [ + { + "bbox": [ + 106, + 105, + 213, + 119 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 213, + 119 + ], + "score": 1.0, + "content": "A.7.1 ENVIRONMENTS", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 126, + 505, + 171 + ], + "lines": [ + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 299, + 139 + ], + "score": 1.0, + "content": "Unless otherwise explicitly stated, we default to", + "type": "text" + }, + { + "bbox": [ + 300, + 127, + 334, + 137 + ], + "score": 0.9, + "content": "K = 2 0", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 126, + 383, + 139 + ], + "score": 1.0, + "content": "and horizon", + "type": "text" + }, + { + "bbox": [ + 383, + 127, + 409, + 137 + ], + "score": 0.82, + "content": "= 2 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 126, + 505, + 139 + ], + "score": 1.0, + "content": "for all RL experiments.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 137, + 505, + 149 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 505, + 149 + ], + "score": 1.0, + "content": "We also use the standard reward normalization in (Mania et al., 2018), and use a global state nor-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 149, + 505, + 160 + ], + "spans": [ + { + "bbox": [ + 106, + 149, + 505, + 160 + ], + "score": 1.0, + "content": "malization (i.e. the same mean, standard deviation normalization values for MDP states are shared", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 160, + 174, + 171 + ], + "spans": [ + { + "bbox": [ + 106, + 160, + 174, + 171 + ], + "score": 1.0, + "content": "across workers).", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 126, + 505, + 171 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 176, + 505, + 264 + ], + "lines": [ + { + "bbox": [ + 106, + 177, + 504, + 188 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 504, + 188 + ], + "score": 1.0, + "content": "For the Ant environments (Goal-Position Ant, Forward-Backward Ant), there are significant differ-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 188, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 505, + 200 + ], + "score": 1.0, + "content": "ences in weighting on the auxiliary rewards such as control costs, contact costs, and survival rewards", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 199, + 505, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 505, + 211 + ], + "score": 1.0, + "content": "across different previous work (e.g. those costs are downweighted in (Finn et al., 2017) whereas the", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 210, + 505, + 221 + ], + "spans": [ + { + "bbox": [ + 106, + 210, + 505, + 221 + ], + "score": 1.0, + "content": "coefficients are vanilla Gym weightings in (Liu et al., 2019)). These auxiliary rewards can lead to", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 220, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 505, + 234 + ], + "score": 1.0, + "content": "local minima, such as the agent staying stationary to collect the survival bonus which may be con-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 231, + 505, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 505, + 244 + ], + "score": 1.0, + "content": "fused with movement progress when presenting a training curve. To make sure the agent is explicitly", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 243, + 505, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 505, + 255 + ], + "score": 1.0, + "content": "performing the required task, we opted to remove such costs in our work and only present the main", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 253, + 359, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 359, + 266 + ], + "score": 1.0, + "content": "goal-distance cost and forward-movement reward respectively.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 177, + 505, + 266 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 270, + 504, + 293 + ], + "lines": [ + { + "bbox": [ + 105, + 268, + 505, + 283 + ], + "spans": [ + { + "bbox": [ + 105, + 268, + 505, + 283 + ], + "score": 1.0, + "content": "For the other environments, we used default weightings and rewards, since they do not change across", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 281, + 173, + 293 + ], + "spans": [ + { + "bbox": [ + 104, + 281, + 173, + 293 + ], + "score": 1.0, + "content": "previous works.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5, + "bbox_fs": [ + 104, + 268, + 505, + 293 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 305, + 281, + 317 + ], + "lines": [ + { + "bbox": [ + 106, + 305, + 282, + 318 + ], + "spans": [ + { + "bbox": [ + 106, + 305, + 282, + 318 + ], + "score": 1.0, + "content": "A.7.2 ES-MAML HYPERPARAMETERS", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 326, + 504, + 349 + ], + "lines": [ + { + "bbox": [ + 105, + 325, + 505, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 123, + 339 + ], + "score": 1.0, + "content": "Let", + "type": "text" + }, + { + "bbox": [ + 123, + 327, + 134, + 336 + ], + "score": 0.81, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 134, + 325, + 505, + 339 + ], + "score": 1.0, + "content": "be the number of possible distinct tasks possible. We sample tasks without replacement,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 337, + 460, + 350 + ], + "spans": [ + { + "bbox": [ + 106, + 337, + 192, + 350 + ], + "score": 1.0, + "content": "which is important if", + "type": "text" + }, + { + "bbox": [ + 192, + 338, + 223, + 348 + ], + "score": 0.9, + "content": "N \\ll 5", + "type": "inline_equation" + }, + { + "bbox": [ + 223, + 337, + 460, + 350 + ], + "score": 1.0, + "content": ", as each worker performs adaptations on all possible tasks.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5, + "bbox_fs": [ + 105, + 325, + 505, + 350 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 354, + 393, + 366 + ], + "lines": [ + { + "bbox": [ + 105, + 352, + 394, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 394, + 369 + ], + "score": 1.0, + "content": "For standard ES-MAML (Algorithm 3), we used the following settings.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19, + "bbox_fs": [ + 105, + 352, + 394, + 369 + ] + }, + { + "type": "table", + "bbox": [ + 155, + 376, + 455, + 528 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 155, + 376, + 455, + 528 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 155, + 376, + 455, + 528 + ], + "spans": [ + { + "bbox": [ + 155, + 376, + 455, + 528 + ], + "score": 0.985, + "html": "
SettingValue
(Total Workers,#Perturbations,#Current Evals)(300,150,150)
(Train SetSize,Task Batch Size,Test SetSize)(50,5,5) or (N,N,N)
Number of rolloutsper parameter1
NumberofPerturbationsperworker1
Outer-Loop Precision Parameter0.1
AdaptationPrecision Parameter0.1
Outer-Loop Step Size0.01
Adaptation Step Size (α)0.05
Hidden Layer Width32
ES Estimation TypeForward-FD
Reward NormalizationTrue
State NormalizationTrue
", + "type": "table", + "image_path": "190df265e3a35fe05a19895ef94cc0df21f3ab6223d2ed01cad0130a9f274663.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 155, + 376, + 455, + 426.6666666666667 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 155, + 426.6666666666667, + 455, + 477.33333333333337 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 155, + 477.33333333333337, + 455, + 528.0 + ], + "spans": [], + "index": 22 + } + ] + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 537, + 504, + 560 + ], + "lines": [ + { + "bbox": [ + 105, + 536, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 505, + 551 + ], + "score": 1.0, + "content": "For ES-MAML and PG-MAML, we took 3 seeded runs, using the default TRPO hyperparameters", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 548, + 214, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 548, + 214, + 559 + ], + "score": 1.0, + "content": "found in (Liu et al., 2019).", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 536, + 505, + 559 + ] + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file