diff --git "a/parse/train/a7APmM4B9d/a7APmM4B9d_middle.json" "b/parse/train/a7APmM4B9d/a7APmM4B9d_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/a7APmM4B9d/a7APmM4B9d_middle.json" @@ -0,0 +1,33918 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 164, + 97, + 448, + 137 + ], + "lines": [ + { + "bbox": [ + 164, + 97, + 448, + 117 + ], + "spans": [ + { + "bbox": [ + 164, + 97, + 448, + 117 + ], + "score": 1.0, + "content": "Decision Transformer: Reinforcement", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 182, + 117, + 429, + 138 + ], + "spans": [ + { + "bbox": [ + 182, + 117, + 429, + 138 + ], + "score": 1.0, + "content": "Learning via Sequence Modeling", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 110, + 178, + 493, + 206 + ], + "lines": [ + { + "bbox": [ + 171, + 178, + 437, + 192 + ], + "spans": [ + { + "bbox": [ + 171, + 178, + 255, + 192 + ], + "score": 1.0, + "content": "Lili Chen∗,1, Kevin", + "type": "text" + }, + { + "bbox": [ + 255, + 178, + 280, + 190 + ], + "score": 0.61, + "content": "\\mathbf { L u } ^ { * , 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 178, + 437, + 192 + ], + "score": 1.0, + "content": ", Aravind Rajeswaran2, Kimin Lee1,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 111, + 193, + 496, + 206 + ], + "spans": [ + { + "bbox": [ + 111, + 193, + 496, + 206 + ], + "score": 1.0, + "content": "Aditya Grover2,3, Michael Laskin1, Pieter Abbeel1, Aravind Srinivas†,4, Igor Mordatch†,5", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 229, + 208, + 380, + 220 + ], + "lines": [ + { + "bbox": [ + 228, + 206, + 381, + 224 + ], + "spans": [ + { + "bbox": [ + 228, + 206, + 381, + 224 + ], + "score": 1.0, + "content": "∗equal contribution †equal advising", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 146, + 223, + 462, + 236 + ], + "lines": [ + { + "bbox": [ + 145, + 221, + 464, + 239 + ], + "spans": [ + { + "bbox": [ + 145, + 221, + 464, + 239 + ], + "score": 1.0, + "content": "1UC Berkeley 2Facebook AI Research 3UCLA 4OpenAI 5Google Brain", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 233, + 241, + 379, + 252 + ], + "lines": [ + { + "bbox": [ + 231, + 240, + 380, + 254 + ], + "spans": [ + { + "bbox": [ + 231, + 240, + 380, + 254 + ], + "score": 1.0, + "content": "{lilichen, kzl}@berkeley.edu", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "title", + "bbox": [ + 283, + 281, + 328, + 294 + ], + "lines": [ + { + "bbox": [ + 281, + 280, + 330, + 295 + ], + "spans": [ + { + "bbox": [ + 281, + 280, + 330, + 295 + ], + "score": 1.0, + "content": "Abstract", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 142, + 304, + 470, + 436 + ], + "lines": [ + { + "bbox": [ + 142, + 304, + 471, + 317 + ], + "spans": [ + { + "bbox": [ + 142, + 304, + 471, + 317 + ], + "score": 1.0, + "content": "We introduce a framework that abstracts Reinforcement Learning (RL) as a se-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 315, + 471, + 329 + ], + "spans": [ + { + "bbox": [ + 141, + 315, + 471, + 329 + ], + "score": 1.0, + "content": "quence modeling problem. This allows us to draw upon the simplicity and scalabil-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 140, + 325, + 470, + 340 + ], + "spans": [ + { + "bbox": [ + 140, + 325, + 470, + 340 + ], + "score": 1.0, + "content": "ity of the Transformer architecture, and associated advances in language modeling", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 337, + 470, + 350 + ], + "spans": [ + { + "bbox": [ + 141, + 337, + 198, + 350 + ], + "score": 1.0, + "content": "such as GPT-", + "type": "text" + }, + { + "bbox": [ + 199, + 339, + 205, + 348 + ], + "score": 0.47, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 337, + 470, + 350 + ], + "score": 1.0, + "content": "and BERT. In particular, we present Decision Transformer, an", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 349, + 471, + 361 + ], + "spans": [ + { + "bbox": [ + 141, + 349, + 471, + 361 + ], + "score": 1.0, + "content": "architecture that casts the problem of RL as conditional sequence modeling. Un-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 360, + 470, + 372 + ], + "spans": [ + { + "bbox": [ + 141, + 360, + 470, + 372 + ], + "score": 1.0, + "content": "like prior approaches to RL that fit value functions or compute policy gradients,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 370, + 470, + 383 + ], + "spans": [ + { + "bbox": [ + 141, + 370, + 470, + 383 + ], + "score": 1.0, + "content": "Decision Transformer simply outputs the optimal actions by leveraging a causally", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 381, + 470, + 393 + ], + "spans": [ + { + "bbox": [ + 141, + 381, + 470, + 393 + ], + "score": 1.0, + "content": "masked Transformer. By conditioning an autoregressive model on the desired", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 392, + 470, + 405 + ], + "spans": [ + { + "bbox": [ + 141, + 392, + 470, + 405 + ], + "score": 1.0, + "content": "return (reward), past states, and actions, our Decision Transformer model can gen-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 403, + 469, + 415 + ], + "spans": [ + { + "bbox": [ + 141, + 403, + 469, + 415 + ], + "score": 1.0, + "content": "erate future actions that achieve the desired return. Despite its simplicity, Decision", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 414, + 469, + 426 + ], + "spans": [ + { + "bbox": [ + 141, + 414, + 469, + 426 + ], + "score": 1.0, + "content": "Transformer matches or exceeds the performance of state-of-the-art model-free", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 142, + 425, + 417, + 437 + ], + "spans": [ + { + "bbox": [ + 142, + 425, + 417, + 437 + ], + "score": 1.0, + "content": "offline RL baselines on Atari, OpenAI Gym, and Key-to-Door tasks.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 13.5 + }, + { + "type": "image", + "bbox": [ + 113, + 456, + 500, + 636 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 113, + 456, + 500, + 636 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 113, + 456, + 500, + 636 + ], + "spans": [ + { + "bbox": [ + 113, + 456, + 500, + 636 + ], + "score": 0.963, + "type": "image", + "image_path": "1a24cd0765714aa601fab185d61614e5c237741df36ea350b02c6e428b196d29.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 113, + 456, + 500, + 516.0 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 113, + 516.0, + 500, + 576.0 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 113, + 576.0, + 500, + 636.0 + ], + "spans": [], + "index": 22 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 657, + 505, + 691 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 657, + 506, + 671 + ], + "spans": [ + { + "bbox": [ + 106, + 657, + 506, + 671 + ], + "score": 1.0, + "content": "Figure 1: Decision Transformer architecture1. States, actions, and returns are fed into modality-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 669, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 669, + 505, + 681 + ], + "score": 1.0, + "content": "specific linear embeddings and a positional episodic timestep encoding is added. Tokens are fed into", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 679, + 483, + 692 + ], + "spans": [ + { + "bbox": [ + 105, + 679, + 483, + 692 + ], + "score": 1.0, + "content": "a GPT architecture which predicts actions autoregressively using a causal self-attention mask.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24 + } + ], + "index": 22.5 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 731, + 385, + 742 + ], + "lines": [ + { + "bbox": [ + 106, + 730, + 386, + 743 + ], + "spans": [ + { + "bbox": [ + 106, + 730, + 386, + 743 + ], + "score": 1.0, + "content": "35th Conference on Neural Information Processing Systems (NeurIPS 2021).", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 114, + 704, + 487, + 715 + ], + "lines": [ + { + "bbox": [ + 119, + 702, + 488, + 717 + ], + "spans": [ + { + "bbox": [ + 119, + 702, + 488, + 717 + ], + "score": 1.0, + "content": "1Our code is available at: https://sites.google.com/berkeley.edu/decision-transformer", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 164, + 97, + 448, + 137 + ], + "lines": [ + { + "bbox": [ + 164, + 97, + 448, + 117 + ], + "spans": [ + { + "bbox": [ + 164, + 97, + 448, + 117 + ], + "score": 1.0, + "content": "Decision Transformer: Reinforcement", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 182, + 117, + 429, + 138 + ], + "spans": [ + { + "bbox": [ + 182, + 117, + 429, + 138 + ], + "score": 1.0, + "content": "Learning via Sequence Modeling", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 110, + 178, + 493, + 206 + ], + "lines": [ + { + "bbox": [ + 171, + 178, + 437, + 192 + ], + "spans": [ + { + "bbox": [ + 171, + 178, + 255, + 192 + ], + "score": 1.0, + "content": "Lili Chen∗,1, Kevin", + "type": "text" + }, + { + "bbox": [ + 255, + 178, + 280, + 190 + ], + "score": 0.61, + "content": "\\mathbf { L u } ^ { * , 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 178, + 437, + 192 + ], + "score": 1.0, + "content": ", Aravind Rajeswaran2, Kimin Lee1,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 111, + 193, + 496, + 206 + ], + "spans": [ + { + "bbox": [ + 111, + 193, + 496, + 206 + ], + "score": 1.0, + "content": "Aditya Grover2,3, Michael Laskin1, Pieter Abbeel1, Aravind Srinivas†,4, Igor Mordatch†,5", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5, + "bbox_fs": [ + 111, + 178, + 496, + 206 + ] + }, + { + "type": "text", + "bbox": [ + 229, + 208, + 380, + 220 + ], + "lines": [ + { + "bbox": [ + 228, + 206, + 381, + 224 + ], + "spans": [ + { + "bbox": [ + 228, + 206, + 381, + 224 + ], + "score": 1.0, + "content": "∗equal contribution †equal advising", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4, + "bbox_fs": [ + 228, + 206, + 381, + 224 + ] + }, + { + "type": "text", + "bbox": [ + 146, + 223, + 462, + 236 + ], + "lines": [ + { + "bbox": [ + 145, + 221, + 464, + 239 + ], + "spans": [ + { + "bbox": [ + 145, + 221, + 464, + 239 + ], + "score": 1.0, + "content": "1UC Berkeley 2Facebook AI Research 3UCLA 4OpenAI 5Google Brain", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5, + "bbox_fs": [ + 145, + 221, + 464, + 239 + ] + }, + { + "type": "text", + "bbox": [ + 233, + 241, + 379, + 252 + ], + "lines": [ + { + "bbox": [ + 231, + 240, + 380, + 254 + ], + "spans": [ + { + "bbox": [ + 231, + 240, + 380, + 254 + ], + "score": 1.0, + "content": "{lilichen, kzl}@berkeley.edu", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6, + "bbox_fs": [ + 231, + 240, + 380, + 254 + ] + }, + { + "type": "title", + "bbox": [ + 283, + 281, + 328, + 294 + ], + "lines": [ + { + "bbox": [ + 281, + 280, + 330, + 295 + ], + "spans": [ + { + "bbox": [ + 281, + 280, + 330, + 295 + ], + "score": 1.0, + "content": "Abstract", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 142, + 304, + 470, + 436 + ], + "lines": [ + { + "bbox": [ + 142, + 304, + 471, + 317 + ], + "spans": [ + { + "bbox": [ + 142, + 304, + 471, + 317 + ], + "score": 1.0, + "content": "We introduce a framework that abstracts Reinforcement Learning (RL) as a se-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 315, + 471, + 329 + ], + "spans": [ + { + "bbox": [ + 141, + 315, + 471, + 329 + ], + "score": 1.0, + "content": "quence modeling problem. This allows us to draw upon the simplicity and scalabil-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 140, + 325, + 470, + 340 + ], + "spans": [ + { + "bbox": [ + 140, + 325, + 470, + 340 + ], + "score": 1.0, + "content": "ity of the Transformer architecture, and associated advances in language modeling", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 337, + 470, + 350 + ], + "spans": [ + { + "bbox": [ + 141, + 337, + 198, + 350 + ], + "score": 1.0, + "content": "such as GPT-", + "type": "text" + }, + { + "bbox": [ + 199, + 339, + 205, + 348 + ], + "score": 0.47, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 337, + 470, + 350 + ], + "score": 1.0, + "content": "and BERT. In particular, we present Decision Transformer, an", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 349, + 471, + 361 + ], + "spans": [ + { + "bbox": [ + 141, + 349, + 471, + 361 + ], + "score": 1.0, + "content": "architecture that casts the problem of RL as conditional sequence modeling. Un-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 360, + 470, + 372 + ], + "spans": [ + { + "bbox": [ + 141, + 360, + 470, + 372 + ], + "score": 1.0, + "content": "like prior approaches to RL that fit value functions or compute policy gradients,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 370, + 470, + 383 + ], + "spans": [ + { + "bbox": [ + 141, + 370, + 470, + 383 + ], + "score": 1.0, + "content": "Decision Transformer simply outputs the optimal actions by leveraging a causally", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 381, + 470, + 393 + ], + "spans": [ + { + "bbox": [ + 141, + 381, + 470, + 393 + ], + "score": 1.0, + "content": "masked Transformer. By conditioning an autoregressive model on the desired", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 392, + 470, + 405 + ], + "spans": [ + { + "bbox": [ + 141, + 392, + 470, + 405 + ], + "score": 1.0, + "content": "return (reward), past states, and actions, our Decision Transformer model can gen-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 403, + 469, + 415 + ], + "spans": [ + { + "bbox": [ + 141, + 403, + 469, + 415 + ], + "score": 1.0, + "content": "erate future actions that achieve the desired return. Despite its simplicity, Decision", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 414, + 469, + 426 + ], + "spans": [ + { + "bbox": [ + 141, + 414, + 469, + 426 + ], + "score": 1.0, + "content": "Transformer matches or exceeds the performance of state-of-the-art model-free", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 142, + 425, + 417, + 437 + ], + "spans": [ + { + "bbox": [ + 142, + 425, + 417, + 437 + ], + "score": 1.0, + "content": "offline RL baselines on Atari, OpenAI Gym, and Key-to-Door tasks.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 13.5, + "bbox_fs": [ + 140, + 304, + 471, + 437 + ] + }, + { + "type": "image", + "bbox": [ + 113, + 456, + 500, + 636 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 113, + 456, + 500, + 636 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 113, + 456, + 500, + 636 + ], + "spans": [ + { + "bbox": [ + 113, + 456, + 500, + 636 + ], + "score": 0.963, + "type": "image", + "image_path": "1a24cd0765714aa601fab185d61614e5c237741df36ea350b02c6e428b196d29.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 113, + 456, + 500, + 516.0 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 113, + 516.0, + 500, + 576.0 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 113, + 576.0, + 500, + 636.0 + ], + "spans": [], + "index": 22 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 657, + 505, + 691 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 657, + 506, + 671 + ], + "spans": [ + { + "bbox": [ + 106, + 657, + 506, + 671 + ], + "score": 1.0, + "content": "Figure 1: Decision Transformer architecture1. States, actions, and returns are fed into modality-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 669, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 669, + 505, + 681 + ], + "score": 1.0, + "content": "specific linear embeddings and a positional episodic timestep encoding is added. Tokens are fed into", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 679, + 483, + 692 + ], + "spans": [ + { + "bbox": [ + 105, + 679, + 483, + 692 + ], + "score": 1.0, + "content": "a GPT architecture which predicts actions autoregressively using a causal self-attention mask.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24 + } + ], + "index": 22.5 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 109, + 69, + 504, + 153 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 69, + 504, + 153 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 69, + 504, + 153 + ], + "spans": [ + { + "bbox": [ + 109, + 69, + 504, + 153 + ], + "score": 0.95, + "type": "image", + "image_path": "0797a951d243f2314131b11d4b2498080d4ff7e99afe42059cf1db90aad8dccc.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 109, + 69, + 504, + 97.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 109, + 97.0, + 504, + 125.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 109, + 125.0, + 504, + 153.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 176, + 505, + 221 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 176, + 506, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 506, + 189 + ], + "score": 1.0, + "content": "Figure 2: Illustrative example of finding shortest path for a fixed graph (left) posed as reinforcement", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "score": 1.0, + "content": "learning. Training dataset consists of random walk trajectories and their per-node returns-to-go", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 198, + 506, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 506, + 212 + ], + "score": 1.0, + "content": "(middle). Conditioned on a starting state and generating largest possible return at each node, Decision", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 210, + 259, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 210, + 259, + 222 + ], + "score": 1.0, + "content": "Transformer sequences optimal paths.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "title", + "bbox": [ + 107, + 248, + 190, + 262 + ], + "lines": [ + { + "bbox": [ + 104, + 247, + 192, + 264 + ], + "spans": [ + { + "bbox": [ + 104, + 247, + 192, + 264 + ], + "score": 1.0, + "content": "1 Introduction", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 279, + 505, + 367 + ], + "lines": [ + { + "bbox": [ + 105, + 279, + 506, + 292 + ], + "spans": [ + { + "bbox": [ + 105, + 279, + 506, + 292 + ], + "score": 1.0, + "content": "Recent work has shown transformers [1] can model large-scale distributions of semantic concepts,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 290, + 505, + 303 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 505, + 303 + ], + "score": 1.0, + "content": "including capable zero-shot generalization in language [2] and impressive out-of-distribution image", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 302, + 505, + 313 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 505, + 313 + ], + "score": 1.0, + "content": "generation [3]. This stands in sharp contrast to much work in reinforcement learning (RL), which", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 313, + 506, + 325 + ], + "spans": [ + { + "bbox": [ + 106, + 313, + 506, + 325 + ], + "score": 1.0, + "content": "learns a single policy to model a particular narrow behavior distribution. Given the diversity of", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 324, + 506, + 336 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 506, + 336 + ], + "score": 1.0, + "content": "applications and impact of transformer models, we seek to examine their application to sequential", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 333, + 506, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 333, + 506, + 347 + ], + "score": 1.0, + "content": "decision making problems. In particular, instead of using transformers as an architectural choice", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 344, + 505, + 359 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 505, + 359 + ], + "score": 1.0, + "content": "for traditional RL algorithms [4, 5], we seek to study if trajectory modeling (analogous to language", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 357, + 389, + 369 + ], + "spans": [ + { + "bbox": [ + 106, + 357, + 389, + 369 + ], + "score": 1.0, + "content": "modeling) can serve as a replacement for conventional RL algorithms.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 106, + 372, + 505, + 569 + ], + "lines": [ + { + "bbox": [ + 105, + 371, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 505, + 385 + ], + "score": 1.0, + "content": "We consider the following shift in paradigm: instead of training a policy through conventional", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 383, + 505, + 396 + ], + "spans": [ + { + "bbox": [ + 106, + 383, + 505, + 396 + ], + "score": 1.0, + "content": "RL algorithms like temporal difference (TD) learning [6], the dominant paradigm in RL, we will", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 394, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 505, + 407 + ], + "score": 1.0, + "content": "train transformer models on collected experience using a sequence modeling objective. This will", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 405, + 506, + 419 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 506, + 419 + ], + "score": 1.0, + "content": "allow us to bypass the need for bootstrapping to propagate returns – thereby avoiding one of the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 415, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 505, + 429 + ], + "score": 1.0, + "content": "“deadly triad” [6] known to destabilize RL. It also avoids the need for discounting future rewards, as", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 427, + 506, + 440 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 506, + 440 + ], + "score": 1.0, + "content": "typically done in TD-learning, which can induce undesirable short-sighted behaviors. Additionally,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 438, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 106, + 438, + 505, + 450 + ], + "score": 1.0, + "content": "we can make use of existing transformer frameworks widely used in language and vision that are", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 449, + 505, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 449, + 505, + 462 + ], + "score": 1.0, + "content": "easy to scale, utilizing a large body of work studying stable training of transformer models; this", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 460, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 506, + 473 + ], + "score": 1.0, + "content": "approach removes the need for specialized RL frameworks by appealing only to commonplace", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 471, + 506, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 506, + 483 + ], + "score": 1.0, + "content": "supervised learning systems. Given their demonstrated ability to model long sequences and wide data", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 480, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 506, + 494 + ], + "score": 1.0, + "content": "distributions, transformers also have other advantages. Transformers can perform credit assignment", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 493, + 506, + 505 + ], + "spans": [ + { + "bbox": [ + 106, + 493, + 506, + 505 + ], + "score": 1.0, + "content": "directly via self-attention, in contrast to Bellman backups which slowly propagate rewards and", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 504, + 506, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 506, + 515 + ], + "score": 1.0, + "content": "are prone to “distractor” signals [7]. This can enable transformers to still work effectively in the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 104, + 514, + 506, + 527 + ], + "spans": [ + { + "bbox": [ + 104, + 514, + 506, + 527 + ], + "score": 1.0, + "content": "presence of sparse or distracting rewards. Furthermore, a transformer modeling approach can model", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 525, + 506, + 538 + ], + "spans": [ + { + "bbox": [ + 104, + 525, + 506, + 538 + ], + "score": 1.0, + "content": "a wide distribution of behaviors, enabling better generalization and transfer. While “upside-down”", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 535, + 507, + 550 + ], + "spans": [ + { + "bbox": [ + 104, + 535, + 507, + 550 + ], + "score": 1.0, + "content": "reinforcement learning (UDRL) [8, 9, 10] also uses a supervised loss conditioned on a target return,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 547, + 506, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 506, + 560 + ], + "score": 1.0, + "content": "our work is motivated by sequence modeling rather than supervised learning and seeks to benefit", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 558, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 506, + 570 + ], + "score": 1.0, + "content": "from modeling long sequences of behaviors. See Section 6 for more discussions about related works.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 107, + 574, + 505, + 651 + ], + "lines": [ + { + "bbox": [ + 105, + 573, + 506, + 587 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 506, + 587 + ], + "score": 1.0, + "content": "We explore our hypothesis by considering offline RL, where we will task agents with learning policies", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 584, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 505, + 599 + ], + "score": 1.0, + "content": "from suboptimal data – producing maximally effective behavior from fixed, limited experience. This", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 596, + 506, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 506, + 609 + ], + "score": 1.0, + "content": "task is traditionally challenging due to error propagation and value overestimation [11]. However, it is", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 607, + 505, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 505, + 620 + ], + "score": 1.0, + "content": "a natural task when training with a sequence modeling objective. By training an autoregressive model", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 618, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 506, + 631 + ], + "score": 1.0, + "content": "on sequences of states, actions, and returns, we reduce policy sampling to autoregressive generative", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 628, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 505, + 643 + ], + "score": 1.0, + "content": "modeling. We can specify the expertise of the policy – which “skill” to query – by manually setting", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 639, + 315, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 315, + 653 + ], + "score": 1.0, + "content": "the return tokens, acting as a prompt for generation.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 106, + 656, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 656, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 106, + 656, + 505, + 668 + ], + "score": 1.0, + "content": "Illustrative example. To get an intuition for our proposal, consider the task of finding a shortest path", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 667, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 449, + 678 + ], + "score": 1.0, + "content": "on a directed graph posed as an RL problem. The reward is 0 when at the goal node and", + "type": "text" + }, + { + "bbox": [ + 449, + 668, + 463, + 678 + ], + "score": 0.71, + "content": "- 1", + "type": "inline_equation" + }, + { + "bbox": [ + 463, + 667, + 506, + 678 + ], + "score": 1.0, + "content": "otherwise.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 677, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 691 + ], + "score": 1.0, + "content": "We train a GPT [12] model to predict next token in a sequence of returns-to-go (sum of future", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 689, + 505, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 505, + 702 + ], + "score": 1.0, + "content": "rewards), states, and actions. Training only on random walk data – with no expert demonstrations", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 104, + 700, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 104, + 700, + 505, + 713 + ], + "score": 1.0, + "content": "– we can at test time generate optimal trajectories by adding a prior to generate highest possible", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 712, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 712, + 505, + 723 + ], + "score": 1.0, + "content": "returns (see more details and empirical results in the Appendix) and subsequently generate actions", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 43.5 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 740, + 310, + 753 + ], + "spans": [ + { + "bbox": [ + 301, + 740, + 310, + 753 + ], + "score": 1.0, + "content": "2", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 109, + 69, + 504, + 153 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 69, + 504, + 153 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 69, + 504, + 153 + ], + "spans": [ + { + "bbox": [ + 109, + 69, + 504, + 153 + ], + "score": 0.95, + "type": "image", + "image_path": "0797a951d243f2314131b11d4b2498080d4ff7e99afe42059cf1db90aad8dccc.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 109, + 69, + 504, + 97.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 109, + 97.0, + 504, + 125.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 109, + 125.0, + 504, + 153.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 176, + 505, + 221 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 176, + 506, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 506, + 189 + ], + "score": 1.0, + "content": "Figure 2: Illustrative example of finding shortest path for a fixed graph (left) posed as reinforcement", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "score": 1.0, + "content": "learning. Training dataset consists of random walk trajectories and their per-node returns-to-go", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 198, + 506, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 506, + 212 + ], + "score": 1.0, + "content": "(middle). Conditioned on a starting state and generating largest possible return at each node, Decision", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 210, + 259, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 210, + 259, + 222 + ], + "score": 1.0, + "content": "Transformer sequences optimal paths.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "title", + "bbox": [ + 107, + 248, + 190, + 262 + ], + "lines": [ + { + "bbox": [ + 104, + 247, + 192, + 264 + ], + "spans": [ + { + "bbox": [ + 104, + 247, + 192, + 264 + ], + "score": 1.0, + "content": "1 Introduction", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 279, + 505, + 367 + ], + "lines": [ + { + "bbox": [ + 105, + 279, + 506, + 292 + ], + "spans": [ + { + "bbox": [ + 105, + 279, + 506, + 292 + ], + "score": 1.0, + "content": "Recent work has shown transformers [1] can model large-scale distributions of semantic concepts,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 290, + 505, + 303 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 505, + 303 + ], + "score": 1.0, + "content": "including capable zero-shot generalization in language [2] and impressive out-of-distribution image", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 302, + 505, + 313 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 505, + 313 + ], + "score": 1.0, + "content": "generation [3]. This stands in sharp contrast to much work in reinforcement learning (RL), which", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 313, + 506, + 325 + ], + "spans": [ + { + "bbox": [ + 106, + 313, + 506, + 325 + ], + "score": 1.0, + "content": "learns a single policy to model a particular narrow behavior distribution. Given the diversity of", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 324, + 506, + 336 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 506, + 336 + ], + "score": 1.0, + "content": "applications and impact of transformer models, we seek to examine their application to sequential", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 333, + 506, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 333, + 506, + 347 + ], + "score": 1.0, + "content": "decision making problems. In particular, instead of using transformers as an architectural choice", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 344, + 505, + 359 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 505, + 359 + ], + "score": 1.0, + "content": "for traditional RL algorithms [4, 5], we seek to study if trajectory modeling (analogous to language", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 357, + 389, + 369 + ], + "spans": [ + { + "bbox": [ + 106, + 357, + 389, + 369 + ], + "score": 1.0, + "content": "modeling) can serve as a replacement for conventional RL algorithms.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 279, + 506, + 369 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 372, + 505, + 569 + ], + "lines": [ + { + "bbox": [ + 105, + 371, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 505, + 385 + ], + "score": 1.0, + "content": "We consider the following shift in paradigm: instead of training a policy through conventional", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 383, + 505, + 396 + ], + "spans": [ + { + "bbox": [ + 106, + 383, + 505, + 396 + ], + "score": 1.0, + "content": "RL algorithms like temporal difference (TD) learning [6], the dominant paradigm in RL, we will", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 394, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 505, + 407 + ], + "score": 1.0, + "content": "train transformer models on collected experience using a sequence modeling objective. This will", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 405, + 506, + 419 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 506, + 419 + ], + "score": 1.0, + "content": "allow us to bypass the need for bootstrapping to propagate returns – thereby avoiding one of the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 415, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 505, + 429 + ], + "score": 1.0, + "content": "“deadly triad” [6] known to destabilize RL. It also avoids the need for discounting future rewards, as", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 427, + 506, + 440 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 506, + 440 + ], + "score": 1.0, + "content": "typically done in TD-learning, which can induce undesirable short-sighted behaviors. Additionally,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 438, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 106, + 438, + 505, + 450 + ], + "score": 1.0, + "content": "we can make use of existing transformer frameworks widely used in language and vision that are", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 449, + 505, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 449, + 505, + 462 + ], + "score": 1.0, + "content": "easy to scale, utilizing a large body of work studying stable training of transformer models; this", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 460, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 506, + 473 + ], + "score": 1.0, + "content": "approach removes the need for specialized RL frameworks by appealing only to commonplace", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 471, + 506, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 506, + 483 + ], + "score": 1.0, + "content": "supervised learning systems. Given their demonstrated ability to model long sequences and wide data", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 480, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 506, + 494 + ], + "score": 1.0, + "content": "distributions, transformers also have other advantages. Transformers can perform credit assignment", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 493, + 506, + 505 + ], + "spans": [ + { + "bbox": [ + 106, + 493, + 506, + 505 + ], + "score": 1.0, + "content": "directly via self-attention, in contrast to Bellman backups which slowly propagate rewards and", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 504, + 506, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 506, + 515 + ], + "score": 1.0, + "content": "are prone to “distractor” signals [7]. This can enable transformers to still work effectively in the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 104, + 514, + 506, + 527 + ], + "spans": [ + { + "bbox": [ + 104, + 514, + 506, + 527 + ], + "score": 1.0, + "content": "presence of sparse or distracting rewards. Furthermore, a transformer modeling approach can model", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 525, + 506, + 538 + ], + "spans": [ + { + "bbox": [ + 104, + 525, + 506, + 538 + ], + "score": 1.0, + "content": "a wide distribution of behaviors, enabling better generalization and transfer. While “upside-down”", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 535, + 507, + 550 + ], + "spans": [ + { + "bbox": [ + 104, + 535, + 507, + 550 + ], + "score": 1.0, + "content": "reinforcement learning (UDRL) [8, 9, 10] also uses a supervised loss conditioned on a target return,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 547, + 506, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 506, + 560 + ], + "score": 1.0, + "content": "our work is motivated by sequence modeling rather than supervised learning and seeks to benefit", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 558, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 506, + 570 + ], + "score": 1.0, + "content": "from modeling long sequences of behaviors. See Section 6 for more discussions about related works.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 24.5, + "bbox_fs": [ + 104, + 371, + 507, + 570 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 574, + 505, + 651 + ], + "lines": [ + { + "bbox": [ + 105, + 573, + 506, + 587 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 506, + 587 + ], + "score": 1.0, + "content": "We explore our hypothesis by considering offline RL, where we will task agents with learning policies", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 584, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 505, + 599 + ], + "score": 1.0, + "content": "from suboptimal data – producing maximally effective behavior from fixed, limited experience. This", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 596, + 506, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 506, + 609 + ], + "score": 1.0, + "content": "task is traditionally challenging due to error propagation and value overestimation [11]. However, it is", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 607, + 505, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 505, + 620 + ], + "score": 1.0, + "content": "a natural task when training with a sequence modeling objective. By training an autoregressive model", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 618, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 506, + 631 + ], + "score": 1.0, + "content": "on sequences of states, actions, and returns, we reduce policy sampling to autoregressive generative", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 628, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 505, + 643 + ], + "score": 1.0, + "content": "modeling. We can specify the expertise of the policy – which “skill” to query – by manually setting", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 639, + 315, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 315, + 653 + ], + "score": 1.0, + "content": "the return tokens, acting as a prompt for generation.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 37, + "bbox_fs": [ + 105, + 573, + 506, + 653 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 656, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 656, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 106, + 656, + 505, + 668 + ], + "score": 1.0, + "content": "Illustrative example. To get an intuition for our proposal, consider the task of finding a shortest path", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 667, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 449, + 678 + ], + "score": 1.0, + "content": "on a directed graph posed as an RL problem. The reward is 0 when at the goal node and", + "type": "text" + }, + { + "bbox": [ + 449, + 668, + 463, + 678 + ], + "score": 0.71, + "content": "- 1", + "type": "inline_equation" + }, + { + "bbox": [ + 463, + 667, + 506, + 678 + ], + "score": 1.0, + "content": "otherwise.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 677, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 691 + ], + "score": 1.0, + "content": "We train a GPT [12] model to predict next token in a sequence of returns-to-go (sum of future", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 689, + 505, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 505, + 702 + ], + "score": 1.0, + "content": "rewards), states, and actions. Training only on random walk data – with no expert demonstrations", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 104, + 700, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 104, + 700, + 505, + 713 + ], + "score": 1.0, + "content": "– we can at test time generate optimal trajectories by adding a prior to generate highest possible", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 712, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 712, + 505, + 723 + ], + "score": 1.0, + "content": "returns (see more details and empirical results in the Appendix) and subsequently generate actions", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 72, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 505, + 86 + ], + "score": 1.0, + "content": "conditioned on that. Thus, by combining the tools of sequence modeling with hindsight return", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 82, + 467, + 98 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 467, + 98 + ], + "score": 1.0, + "content": "information, we achieve policy improvement without the need for dynamic programming.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + } + ], + "index": 43.5, + "bbox_fs": [ + 104, + 656, + 506, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 72, + 504, + 95 + ], + "lines": [ + { + "bbox": [ + 106, + 72, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 505, + 86 + ], + "score": 1.0, + "content": "conditioned on that. Thus, by combining the tools of sequence modeling with hindsight return", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 82, + 467, + 98 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 467, + 98 + ], + "score": 1.0, + "content": "information, we achieve policy improvement without the need for dynamic programming.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 106, + 100, + 505, + 188 + ], + "lines": [ + { + "bbox": [ + 106, + 100, + 505, + 112 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 505, + 112 + ], + "score": 1.0, + "content": "Motivated by this observation, we propose Decision Transformer, where we use the GPT architecture", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "spans": [ + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "score": 1.0, + "content": "to autoregressively model trajectories (shown in Figure 1). We study whether sequence modeling", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 122, + 505, + 135 + ], + "spans": [ + { + "bbox": [ + 105, + 122, + 505, + 135 + ], + "score": 1.0, + "content": "can perform policy optimization by evaluating Decision Transformer on offline RL benchmarks", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 132, + 506, + 146 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 506, + 146 + ], + "score": 1.0, + "content": "in Atari [13], OpenAI Gym [14], and Key-to-Door [15] environments. We show that – without", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 144, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 106, + 144, + 505, + 156 + ], + "score": 1.0, + "content": "using dynamic programming – Decision Transformer performs comparably on these benchmarks to", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 155, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 155, + 505, + 167 + ], + "score": 1.0, + "content": "state-of-the-art model-free offline RL algorithms [16, 17]. Furthermore, in tasks where long-term", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "score": 1.0, + "content": "credit assignment is required, Decision Transformer capably outperforms RL algorithms. With this", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 176, + 455, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 455, + 189 + ], + "score": 1.0, + "content": "work, we hope to bridge vast recent progress in transformer models with RL problems.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 5.5 + }, + { + "type": "title", + "bbox": [ + 107, + 202, + 195, + 216 + ], + "lines": [ + { + "bbox": [ + 104, + 200, + 196, + 219 + ], + "spans": [ + { + "bbox": [ + 104, + 200, + 196, + 219 + ], + "score": 1.0, + "content": "2 Preliminaries", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "title", + "bbox": [ + 108, + 226, + 260, + 239 + ], + "lines": [ + { + "bbox": [ + 105, + 224, + 261, + 241 + ], + "spans": [ + { + "bbox": [ + 105, + 224, + 261, + 241 + ], + "score": 1.0, + "content": "2.1 Offline reinforcement learning", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 246, + 505, + 342 + ], + "lines": [ + { + "bbox": [ + 106, + 246, + 505, + 258 + ], + "spans": [ + { + "bbox": [ + 106, + 246, + 429, + 258 + ], + "score": 1.0, + "content": "We consider learning in a Markov decision process (MDP) described by the tuple", + "type": "text" + }, + { + "bbox": [ + 430, + 246, + 483, + 258 + ], + "score": 0.87, + "content": "( \\boldsymbol { S } , \\mathcal { A } , \\boldsymbol { P } , \\mathcal { R } )", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 246, + 505, + 258 + ], + "score": 1.0, + "content": ". The", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 258, + 505, + 270 + ], + "spans": [ + { + "bbox": [ + 106, + 258, + 226, + 270 + ], + "score": 1.0, + "content": "MDP tuple consists of states", + "type": "text" + }, + { + "bbox": [ + 227, + 258, + 253, + 268 + ], + "score": 0.9, + "content": "s \\in S", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 258, + 288, + 270 + ], + "score": 1.0, + "content": ", actions", + "type": "text" + }, + { + "bbox": [ + 289, + 258, + 317, + 268 + ], + "score": 0.91, + "content": "a \\in { \\mathcal { A } }", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 258, + 404, + 270 + ], + "score": 1.0, + "content": ", transition dynamics", + "type": "text" + }, + { + "bbox": [ + 404, + 258, + 445, + 270 + ], + "score": 0.94, + "content": "P ( s ^ { \\prime } | s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 446, + 258, + 505, + 270 + ], + "score": 1.0, + "content": ", and a reward", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 268, + 506, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 268, + 143, + 281 + ], + "score": 1.0, + "content": "function", + "type": "text" + }, + { + "bbox": [ + 144, + 268, + 193, + 281 + ], + "score": 0.93, + "content": "r = \\mathcal { R } ( s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 194, + 268, + 230, + 281 + ], + "score": 1.0, + "content": ". We use", + "type": "text" + }, + { + "bbox": [ + 231, + 271, + 240, + 280 + ], + "score": 0.74, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 240, + 268, + 244, + 281 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 244, + 271, + 254, + 280 + ], + "score": 0.74, + "content": "a _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 268, + 276, + 281 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 276, + 269, + 336, + 281 + ], + "score": 0.93, + "content": "r _ { t } = \\mathcal { R } ( s _ { t } , a _ { t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 268, + 506, + 281 + ], + "score": 1.0, + "content": "to denote the state, action, and reward at", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 279, + 505, + 292 + ], + "spans": [ + { + "bbox": [ + 106, + 279, + 143, + 292 + ], + "score": 1.0, + "content": "timestep", + "type": "text" + }, + { + "bbox": [ + 144, + 281, + 149, + 289 + ], + "score": 0.7, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 149, + 279, + 505, + 292 + ], + "score": 1.0, + "content": ", respectively. The goal in reinforcement learning is to learn a policy which maximizes", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 286, + 505, + 313 + ], + "spans": [ + { + "bbox": [ + 106, + 286, + 186, + 313 + ], + "score": 1.0, + "content": "the expected return", + "type": "text" + }, + { + "bbox": [ + 186, + 290, + 236, + 311 + ], + "score": 0.93, + "content": "\\mathbb { E } \\left[ \\sum _ { t = 1 } ^ { T } r _ { t } \\right]", + "type": "inline_equation" + }, + { + "bbox": [ + 237, + 286, + 505, + 313 + ], + "score": 1.0, + "content": "in an MDP. In offline reinforcement learning, instead of obtaining", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 307, + 506, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 506, + 320 + ], + "score": 1.0, + "content": "data via environment interactions, we only have access to some fixed limited dataset consisting of", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 320, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 320, + 505, + 331 + ], + "score": 1.0, + "content": "trajectories from the environment. This setting is harder as it removes the ability for agents to explore", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 331, + 302, + 341 + ], + "spans": [ + { + "bbox": [ + 106, + 331, + 302, + 341 + ], + "score": 1.0, + "content": "the environment and collect additional feedback.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 15.5 + }, + { + "type": "title", + "bbox": [ + 107, + 353, + 189, + 365 + ], + "lines": [ + { + "bbox": [ + 105, + 352, + 190, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 190, + 367 + ], + "score": 1.0, + "content": "2.2 Transformers", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 106, + 373, + 505, + 441 + ], + "lines": [ + { + "bbox": [ + 106, + 374, + 506, + 387 + ], + "spans": [ + { + "bbox": [ + 106, + 374, + 506, + 387 + ], + "score": 1.0, + "content": "Transformers were proposed by Vaswani et al. [1] as an architecture to efficiently model sequences.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 384, + 506, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 506, + 398 + ], + "score": 1.0, + "content": "They consist of stacked self-attention layers with residual connections. Each self-attention layer", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 394, + 506, + 411 + ], + "spans": [ + { + "bbox": [ + 104, + 394, + 142, + 411 + ], + "score": 1.0, + "content": "receives", + "type": "text" + }, + { + "bbox": [ + 142, + 398, + 149, + 406 + ], + "score": 0.74, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 150, + 394, + 203, + 411 + ], + "score": 1.0, + "content": "embeddings", + "type": "text" + }, + { + "bbox": [ + 203, + 396, + 236, + 408 + ], + "score": 0.92, + "content": "\\{ x _ { i } \\} _ { i = 1 } ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 236, + 394, + 444, + 411 + ], + "score": 1.0, + "content": "corresponding to unique input tokens, and outputs", + "type": "text" + }, + { + "bbox": [ + 445, + 398, + 452, + 406 + ], + "score": 0.72, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 394, + 506, + 411 + ], + "score": 1.0, + "content": "embeddings", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 107, + 405, + 507, + 422 + ], + "spans": [ + { + "bbox": [ + 107, + 407, + 139, + 419 + ], + "score": 0.9, + "content": "\\{ z _ { i } \\} _ { i = 1 } ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 405, + 295, + 422 + ], + "score": 1.0, + "content": ", preserving the input dimensions. The", + "type": "text" + }, + { + "bbox": [ + 296, + 408, + 300, + 417 + ], + "score": 0.79, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 301, + 405, + 507, + 422 + ], + "score": 1.0, + "content": "-th token is mapped via linear transformations to a", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 417, + 505, + 430 + ], + "spans": [ + { + "bbox": [ + 106, + 417, + 123, + 430 + ], + "score": 1.0, + "content": "key", + "type": "text" + }, + { + "bbox": [ + 123, + 419, + 133, + 429 + ], + "score": 0.85, + "content": "k _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 417, + 162, + 430 + ], + "score": 1.0, + "content": ", query", + "type": "text" + }, + { + "bbox": [ + 163, + 420, + 172, + 429 + ], + "score": 0.82, + "content": "q _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 417, + 217, + 430 + ], + "score": 1.0, + "content": ", and value", + "type": "text" + }, + { + "bbox": [ + 217, + 419, + 226, + 429 + ], + "score": 0.84, + "content": "v _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 417, + 249, + 430 + ], + "score": 1.0, + "content": ". The", + "type": "text" + }, + { + "bbox": [ + 249, + 419, + 254, + 428 + ], + "score": 0.73, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 417, + 505, + 430 + ], + "score": 1.0, + "content": "-th output of the self-attention layer is given by weighting the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 428, + 429, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 134, + 442 + ], + "score": 1.0, + "content": "values", + "type": "text" + }, + { + "bbox": [ + 134, + 430, + 144, + 441 + ], + "score": 0.85, + "content": "v _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 428, + 343, + 442 + ], + "score": 1.0, + "content": "by the normalized dot product between the query", + "type": "text" + }, + { + "bbox": [ + 344, + 431, + 352, + 441 + ], + "score": 0.83, + "content": "q _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 353, + 428, + 414, + 442 + ], + "score": 1.0, + "content": "and other keys", + "type": "text" + }, + { + "bbox": [ + 414, + 429, + 424, + 441 + ], + "score": 0.88, + "content": "k _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 428, + 429, + 442 + ], + "score": 1.0, + "content": ":", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23.5 + }, + { + "type": "interline_equation", + "bbox": [ + 222, + 443, + 389, + 477 + ], + "lines": [ + { + "bbox": [ + 222, + 443, + 389, + 477 + ], + "spans": [ + { + "bbox": [ + 222, + 443, + 389, + 477 + ], + "score": 0.94, + "content": "z _ { i } = \\sum _ { j = 1 } ^ { n } \\operatorname { s o f t m a x } ( \\{ \\langle q _ { i } , k _ { j ^ { \\prime } } \\rangle \\} _ { j ^ { \\prime } = 1 } ^ { n } ) _ { j } \\cdot v _ { j } .", + "type": "interline_equation", + "image_path": "45ad9c3100be001f8f49eccde368e07a614ebaeb981f5d7b9157b67ee92e9f6f.jpg" + } + ] + } + ], + "index": 27.5, + "virtual_lines": [ + { + "bbox": [ + 222, + 443, + 389, + 460.0 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 222, + 460.0, + 389, + 477.0 + ], + "spans": [], + "index": 28 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 479, + 505, + 535 + ], + "lines": [ + { + "bbox": [ + 106, + 479, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 505, + 491 + ], + "score": 1.0, + "content": "This allows the layer to assign “credit” by implicitly forming state-return associations via similarity", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 489, + 506, + 503 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 506, + 503 + ], + "score": 1.0, + "content": "of the query and key vectors (maximizing the dot product). In this work, we use the GPT architec-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 501, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 106, + 501, + 505, + 513 + ], + "score": 1.0, + "content": "ture [12], which modifies the transformer architecture with a causal self-attention mask to enable", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 511, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 378, + 524 + ], + "score": 1.0, + "content": "autoregressive generation, replacing the summation/softmax over the", + "type": "text" + }, + { + "bbox": [ + 378, + 514, + 386, + 522 + ], + "score": 0.75, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 386, + 511, + 505, + 524 + ], + "score": 1.0, + "content": "tokens with only the previous", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 522, + 490, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 200, + 536 + ], + "score": 1.0, + "content": "tokens in the sequence", + "type": "text" + }, + { + "bbox": [ + 200, + 523, + 241, + 535 + ], + "score": 0.9, + "content": "( j \\in \\bar { [ 1 , i ] } )", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 522, + 490, + 536 + ], + "score": 1.0, + "content": ". We defer the other architecture details to the original papers.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31 + }, + { + "type": "title", + "bbox": [ + 106, + 549, + 166, + 562 + ], + "lines": [ + { + "bbox": [ + 104, + 547, + 168, + 564 + ], + "spans": [ + { + "bbox": [ + 104, + 547, + 168, + 564 + ], + "score": 1.0, + "content": "3 Method", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 573, + 505, + 595 + ], + "lines": [ + { + "bbox": [ + 106, + 573, + 505, + 586 + ], + "spans": [ + { + "bbox": [ + 106, + 573, + 505, + 586 + ], + "score": 1.0, + "content": "In this section, we present Decision Transformer, which models trajectories autoregressively with", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 583, + 500, + 596 + ], + "spans": [ + { + "bbox": [ + 106, + 583, + 500, + 596 + ], + "score": 1.0, + "content": "minimal modification to the transformer architecture, as summarized in Figure 1 and Algorithm 1.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 106, + 600, + 505, + 669 + ], + "lines": [ + { + "bbox": [ + 105, + 600, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 506, + 613 + ], + "score": 1.0, + "content": "Trajectory representation. The key desiderata in our choice of trajectory representation are (a) it", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 611, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 505, + 623 + ], + "score": 1.0, + "content": "should enable transformers to learn meaningful patterns and (b) we should be able to conditionally", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 622, + 506, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 506, + 635 + ], + "score": 1.0, + "content": "generate actions at test time. It is nontrivial to model rewards since we would like the model to", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "score": 1.0, + "content": "generate actions based on future desired returns, rather than past rewards. As a result, instead", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 643, + 507, + 662 + ], + "spans": [ + { + "bbox": [ + 104, + 643, + 361, + 662 + ], + "score": 1.0, + "content": "of modeling the rewards directly, we model the returns-to-go", + "type": "text" + }, + { + "bbox": [ + 362, + 644, + 427, + 659 + ], + "score": 0.93, + "content": "\\begin{array} { r } { \\overline { { \\boldsymbol { R } } } _ { t } = \\sum _ { t ^ { \\prime } = t } ^ { T } \\boldsymbol { r } _ { t ^ { \\prime } } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 427, + 643, + 507, + 662 + ], + "score": 1.0, + "content": ". This leads to the", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 657, + 491, + 670 + ], + "spans": [ + { + "bbox": [ + 106, + 657, + 491, + 670 + ], + "score": 1.0, + "content": "following trajectory representation which is amenable to autoregressive training and generation:", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 39.5 + }, + { + "type": "interline_equation", + "bbox": [ + 211, + 671, + 400, + 692 + ], + "lines": [ + { + "bbox": [ + 211, + 671, + 400, + 692 + ], + "spans": [ + { + "bbox": [ + 211, + 671, + 400, + 692 + ], + "score": 0.91, + "content": "\\tau = \\left( \\widehat { R } _ { 1 } , s _ { 1 } , a _ { 1 } , \\widehat { R } _ { 2 } , s _ { 2 } , a _ { 2 } , \\ldots , \\widehat { R } _ { T } , s _ { T } , a _ { T } \\right) .", + "type": "interline_equation", + "image_path": "e7ecd27b166a8ad6f275c8a281f9956f75e0d700ebd3b343f25795d2244d6807.jpg" + } + ] + } + ], + "index": 43, + "virtual_lines": [ + { + "bbox": [ + 211, + 671, + 400, + 692 + ], + "spans": [], + "index": 43 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 699, + 504, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 230, + 712 + ], + "score": 1.0, + "content": "Architecture. We feed the last", + "type": "text" + }, + { + "bbox": [ + 231, + 701, + 241, + 710 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 699, + 441, + 712 + ], + "score": 1.0, + "content": "timesteps into Decision Transformer, for a total of", + "type": "text" + }, + { + "bbox": [ + 441, + 700, + 456, + 710 + ], + "score": 0.84, + "content": "3 K", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 699, + 505, + 712 + ], + "score": 1.0, + "content": "tokens (one", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "for each modality: return-to-go, state, or action). To obtain token embeddings, we learn a linear", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 72, + 504, + 95 + ], + "lines": [], + "index": 0.5, + "bbox_fs": [ + 105, + 72, + 505, + 98 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 100, + 505, + 188 + ], + "lines": [ + { + "bbox": [ + 106, + 100, + 505, + 112 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 505, + 112 + ], + "score": 1.0, + "content": "Motivated by this observation, we propose Decision Transformer, where we use the GPT architecture", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "spans": [ + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "score": 1.0, + "content": "to autoregressively model trajectories (shown in Figure 1). We study whether sequence modeling", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 122, + 505, + 135 + ], + "spans": [ + { + "bbox": [ + 105, + 122, + 505, + 135 + ], + "score": 1.0, + "content": "can perform policy optimization by evaluating Decision Transformer on offline RL benchmarks", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 132, + 506, + 146 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 506, + 146 + ], + "score": 1.0, + "content": "in Atari [13], OpenAI Gym [14], and Key-to-Door [15] environments. We show that – without", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 144, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 106, + 144, + 505, + 156 + ], + "score": 1.0, + "content": "using dynamic programming – Decision Transformer performs comparably on these benchmarks to", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 155, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 155, + 505, + 167 + ], + "score": 1.0, + "content": "state-of-the-art model-free offline RL algorithms [16, 17]. Furthermore, in tasks where long-term", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "score": 1.0, + "content": "credit assignment is required, Decision Transformer capably outperforms RL algorithms. With this", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 176, + 455, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 455, + 189 + ], + "score": 1.0, + "content": "work, we hope to bridge vast recent progress in transformer models with RL problems.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 5.5, + "bbox_fs": [ + 105, + 100, + 506, + 189 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 202, + 195, + 216 + ], + "lines": [ + { + "bbox": [ + 104, + 200, + 196, + 219 + ], + "spans": [ + { + "bbox": [ + 104, + 200, + 196, + 219 + ], + "score": 1.0, + "content": "2 Preliminaries", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "title", + "bbox": [ + 108, + 226, + 260, + 239 + ], + "lines": [ + { + "bbox": [ + 105, + 224, + 261, + 241 + ], + "spans": [ + { + "bbox": [ + 105, + 224, + 261, + 241 + ], + "score": 1.0, + "content": "2.1 Offline reinforcement learning", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 246, + 505, + 342 + ], + "lines": [ + { + "bbox": [ + 106, + 246, + 505, + 258 + ], + "spans": [ + { + "bbox": [ + 106, + 246, + 429, + 258 + ], + "score": 1.0, + "content": "We consider learning in a Markov decision process (MDP) described by the tuple", + "type": "text" + }, + { + "bbox": [ + 430, + 246, + 483, + 258 + ], + "score": 0.87, + "content": "( \\boldsymbol { S } , \\mathcal { A } , \\boldsymbol { P } , \\mathcal { R } )", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 246, + 505, + 258 + ], + "score": 1.0, + "content": ". The", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 258, + 505, + 270 + ], + "spans": [ + { + "bbox": [ + 106, + 258, + 226, + 270 + ], + "score": 1.0, + "content": "MDP tuple consists of states", + "type": "text" + }, + { + "bbox": [ + 227, + 258, + 253, + 268 + ], + "score": 0.9, + "content": "s \\in S", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 258, + 288, + 270 + ], + "score": 1.0, + "content": ", actions", + "type": "text" + }, + { + "bbox": [ + 289, + 258, + 317, + 268 + ], + "score": 0.91, + "content": "a \\in { \\mathcal { A } }", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 258, + 404, + 270 + ], + "score": 1.0, + "content": ", transition dynamics", + "type": "text" + }, + { + "bbox": [ + 404, + 258, + 445, + 270 + ], + "score": 0.94, + "content": "P ( s ^ { \\prime } | s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 446, + 258, + 505, + 270 + ], + "score": 1.0, + "content": ", and a reward", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 268, + 506, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 268, + 143, + 281 + ], + "score": 1.0, + "content": "function", + "type": "text" + }, + { + "bbox": [ + 144, + 268, + 193, + 281 + ], + "score": 0.93, + "content": "r = \\mathcal { R } ( s , a )", + "type": "inline_equation" + }, + { + "bbox": [ + 194, + 268, + 230, + 281 + ], + "score": 1.0, + "content": ". We use", + "type": "text" + }, + { + "bbox": [ + 231, + 271, + 240, + 280 + ], + "score": 0.74, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 240, + 268, + 244, + 281 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 244, + 271, + 254, + 280 + ], + "score": 0.74, + "content": "a _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 268, + 276, + 281 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 276, + 269, + 336, + 281 + ], + "score": 0.93, + "content": "r _ { t } = \\mathcal { R } ( s _ { t } , a _ { t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 268, + 506, + 281 + ], + "score": 1.0, + "content": "to denote the state, action, and reward at", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 279, + 505, + 292 + ], + "spans": [ + { + "bbox": [ + 106, + 279, + 143, + 292 + ], + "score": 1.0, + "content": "timestep", + "type": "text" + }, + { + "bbox": [ + 144, + 281, + 149, + 289 + ], + "score": 0.7, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 149, + 279, + 505, + 292 + ], + "score": 1.0, + "content": ", respectively. The goal in reinforcement learning is to learn a policy which maximizes", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 286, + 505, + 313 + ], + "spans": [ + { + "bbox": [ + 106, + 286, + 186, + 313 + ], + "score": 1.0, + "content": "the expected return", + "type": "text" + }, + { + "bbox": [ + 186, + 290, + 236, + 311 + ], + "score": 0.93, + "content": "\\mathbb { E } \\left[ \\sum _ { t = 1 } ^ { T } r _ { t } \\right]", + "type": "inline_equation" + }, + { + "bbox": [ + 237, + 286, + 505, + 313 + ], + "score": 1.0, + "content": "in an MDP. In offline reinforcement learning, instead of obtaining", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 307, + 506, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 506, + 320 + ], + "score": 1.0, + "content": "data via environment interactions, we only have access to some fixed limited dataset consisting of", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 320, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 320, + 505, + 331 + ], + "score": 1.0, + "content": "trajectories from the environment. This setting is harder as it removes the ability for agents to explore", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 331, + 302, + 341 + ], + "spans": [ + { + "bbox": [ + 106, + 331, + 302, + 341 + ], + "score": 1.0, + "content": "the environment and collect additional feedback.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 246, + 506, + 341 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 353, + 189, + 365 + ], + "lines": [ + { + "bbox": [ + 105, + 352, + 190, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 190, + 367 + ], + "score": 1.0, + "content": "2.2 Transformers", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 106, + 373, + 505, + 441 + ], + "lines": [ + { + "bbox": [ + 106, + 374, + 506, + 387 + ], + "spans": [ + { + "bbox": [ + 106, + 374, + 506, + 387 + ], + "score": 1.0, + "content": "Transformers were proposed by Vaswani et al. [1] as an architecture to efficiently model sequences.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 384, + 506, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 506, + 398 + ], + "score": 1.0, + "content": "They consist of stacked self-attention layers with residual connections. Each self-attention layer", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 394, + 506, + 411 + ], + "spans": [ + { + "bbox": [ + 104, + 394, + 142, + 411 + ], + "score": 1.0, + "content": "receives", + "type": "text" + }, + { + "bbox": [ + 142, + 398, + 149, + 406 + ], + "score": 0.74, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 150, + 394, + 203, + 411 + ], + "score": 1.0, + "content": "embeddings", + "type": "text" + }, + { + "bbox": [ + 203, + 396, + 236, + 408 + ], + "score": 0.92, + "content": "\\{ x _ { i } \\} _ { i = 1 } ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 236, + 394, + 444, + 411 + ], + "score": 1.0, + "content": "corresponding to unique input tokens, and outputs", + "type": "text" + }, + { + "bbox": [ + 445, + 398, + 452, + 406 + ], + "score": 0.72, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 394, + 506, + 411 + ], + "score": 1.0, + "content": "embeddings", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 107, + 405, + 507, + 422 + ], + "spans": [ + { + "bbox": [ + 107, + 407, + 139, + 419 + ], + "score": 0.9, + "content": "\\{ z _ { i } \\} _ { i = 1 } ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 405, + 295, + 422 + ], + "score": 1.0, + "content": ", preserving the input dimensions. The", + "type": "text" + }, + { + "bbox": [ + 296, + 408, + 300, + 417 + ], + "score": 0.79, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 301, + 405, + 507, + 422 + ], + "score": 1.0, + "content": "-th token is mapped via linear transformations to a", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 417, + 505, + 430 + ], + "spans": [ + { + "bbox": [ + 106, + 417, + 123, + 430 + ], + "score": 1.0, + "content": "key", + "type": "text" + }, + { + "bbox": [ + 123, + 419, + 133, + 429 + ], + "score": 0.85, + "content": "k _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 417, + 162, + 430 + ], + "score": 1.0, + "content": ", query", + "type": "text" + }, + { + "bbox": [ + 163, + 420, + 172, + 429 + ], + "score": 0.82, + "content": "q _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 417, + 217, + 430 + ], + "score": 1.0, + "content": ", and value", + "type": "text" + }, + { + "bbox": [ + 217, + 419, + 226, + 429 + ], + "score": 0.84, + "content": "v _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 417, + 249, + 430 + ], + "score": 1.0, + "content": ". The", + "type": "text" + }, + { + "bbox": [ + 249, + 419, + 254, + 428 + ], + "score": 0.73, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 417, + 505, + 430 + ], + "score": 1.0, + "content": "-th output of the self-attention layer is given by weighting the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 428, + 429, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 134, + 442 + ], + "score": 1.0, + "content": "values", + "type": "text" + }, + { + "bbox": [ + 134, + 430, + 144, + 441 + ], + "score": 0.85, + "content": "v _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 428, + 343, + 442 + ], + "score": 1.0, + "content": "by the normalized dot product between the query", + "type": "text" + }, + { + "bbox": [ + 344, + 431, + 352, + 441 + ], + "score": 0.83, + "content": "q _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 353, + 428, + 414, + 442 + ], + "score": 1.0, + "content": "and other keys", + "type": "text" + }, + { + "bbox": [ + 414, + 429, + 424, + 441 + ], + "score": 0.88, + "content": "k _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 428, + 429, + 442 + ], + "score": 1.0, + "content": ":", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23.5, + "bbox_fs": [ + 104, + 374, + 507, + 442 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 222, + 443, + 389, + 477 + ], + "lines": [ + { + "bbox": [ + 222, + 443, + 389, + 477 + ], + "spans": [ + { + "bbox": [ + 222, + 443, + 389, + 477 + ], + "score": 0.94, + "content": "z _ { i } = \\sum _ { j = 1 } ^ { n } \\operatorname { s o f t m a x } ( \\{ \\langle q _ { i } , k _ { j ^ { \\prime } } \\rangle \\} _ { j ^ { \\prime } = 1 } ^ { n } ) _ { j } \\cdot v _ { j } .", + "type": "interline_equation", + "image_path": "45ad9c3100be001f8f49eccde368e07a614ebaeb981f5d7b9157b67ee92e9f6f.jpg" + } + ] + } + ], + "index": 27.5, + "virtual_lines": [ + { + "bbox": [ + 222, + 443, + 389, + 460.0 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 222, + 460.0, + 389, + 477.0 + ], + "spans": [], + "index": 28 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 479, + 505, + 535 + ], + "lines": [ + { + "bbox": [ + 106, + 479, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 505, + 491 + ], + "score": 1.0, + "content": "This allows the layer to assign “credit” by implicitly forming state-return associations via similarity", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 489, + 506, + 503 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 506, + 503 + ], + "score": 1.0, + "content": "of the query and key vectors (maximizing the dot product). In this work, we use the GPT architec-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 501, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 106, + 501, + 505, + 513 + ], + "score": 1.0, + "content": "ture [12], which modifies the transformer architecture with a causal self-attention mask to enable", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 511, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 378, + 524 + ], + "score": 1.0, + "content": "autoregressive generation, replacing the summation/softmax over the", + "type": "text" + }, + { + "bbox": [ + 378, + 514, + 386, + 522 + ], + "score": 0.75, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 386, + 511, + 505, + 524 + ], + "score": 1.0, + "content": "tokens with only the previous", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 522, + 490, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 200, + 536 + ], + "score": 1.0, + "content": "tokens in the sequence", + "type": "text" + }, + { + "bbox": [ + 200, + 523, + 241, + 535 + ], + "score": 0.9, + "content": "( j \\in \\bar { [ 1 , i ] } )", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 522, + 490, + 536 + ], + "score": 1.0, + "content": ". We defer the other architecture details to the original papers.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31, + "bbox_fs": [ + 105, + 479, + 506, + 536 + ] + }, + { + "type": "title", + "bbox": [ + 106, + 549, + 166, + 562 + ], + "lines": [ + { + "bbox": [ + 104, + 547, + 168, + 564 + ], + "spans": [ + { + "bbox": [ + 104, + 547, + 168, + 564 + ], + "score": 1.0, + "content": "3 Method", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 573, + 505, + 595 + ], + "lines": [ + { + "bbox": [ + 106, + 573, + 505, + 586 + ], + "spans": [ + { + "bbox": [ + 106, + 573, + 505, + 586 + ], + "score": 1.0, + "content": "In this section, we present Decision Transformer, which models trajectories autoregressively with", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 583, + 500, + 596 + ], + "spans": [ + { + "bbox": [ + 106, + 583, + 500, + 596 + ], + "score": 1.0, + "content": "minimal modification to the transformer architecture, as summarized in Figure 1 and Algorithm 1.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5, + "bbox_fs": [ + 106, + 573, + 505, + 596 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 600, + 505, + 669 + ], + "lines": [ + { + "bbox": [ + 105, + 600, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 506, + 613 + ], + "score": 1.0, + "content": "Trajectory representation. The key desiderata in our choice of trajectory representation are (a) it", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 611, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 505, + 623 + ], + "score": 1.0, + "content": "should enable transformers to learn meaningful patterns and (b) we should be able to conditionally", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 622, + 506, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 506, + 635 + ], + "score": 1.0, + "content": "generate actions at test time. It is nontrivial to model rewards since we would like the model to", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "score": 1.0, + "content": "generate actions based on future desired returns, rather than past rewards. As a result, instead", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 643, + 507, + 662 + ], + "spans": [ + { + "bbox": [ + 104, + 643, + 361, + 662 + ], + "score": 1.0, + "content": "of modeling the rewards directly, we model the returns-to-go", + "type": "text" + }, + { + "bbox": [ + 362, + 644, + 427, + 659 + ], + "score": 0.93, + "content": "\\begin{array} { r } { \\overline { { \\boldsymbol { R } } } _ { t } = \\sum _ { t ^ { \\prime } = t } ^ { T } \\boldsymbol { r } _ { t ^ { \\prime } } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 427, + 643, + 507, + 662 + ], + "score": 1.0, + "content": ". This leads to the", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 657, + 491, + 670 + ], + "spans": [ + { + "bbox": [ + 106, + 657, + 491, + 670 + ], + "score": 1.0, + "content": "following trajectory representation which is amenable to autoregressive training and generation:", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 39.5, + "bbox_fs": [ + 104, + 600, + 507, + 670 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 211, + 671, + 400, + 692 + ], + "lines": [ + { + "bbox": [ + 211, + 671, + 400, + 692 + ], + "spans": [ + { + "bbox": [ + 211, + 671, + 400, + 692 + ], + "score": 0.91, + "content": "\\tau = \\left( \\widehat { R } _ { 1 } , s _ { 1 } , a _ { 1 } , \\widehat { R } _ { 2 } , s _ { 2 } , a _ { 2 } , \\ldots , \\widehat { R } _ { T } , s _ { T } , a _ { T } \\right) .", + "type": "interline_equation", + "image_path": "e7ecd27b166a8ad6f275c8a281f9956f75e0d700ebd3b343f25795d2244d6807.jpg" + } + ] + } + ], + "index": 43, + "virtual_lines": [ + { + "bbox": [ + 211, + 671, + 400, + 692 + ], + "spans": [], + "index": 43 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 699, + 504, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 230, + 712 + ], + "score": 1.0, + "content": "Architecture. We feed the last", + "type": "text" + }, + { + "bbox": [ + 231, + 701, + 241, + 710 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 699, + 441, + 712 + ], + "score": 1.0, + "content": "timesteps into Decision Transformer, for a total of", + "type": "text" + }, + { + "bbox": [ + 441, + 700, + 456, + 710 + ], + "score": 0.84, + "content": "3 K", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 699, + 505, + 712 + ], + "score": 1.0, + "content": "tokens (one", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "for each modality: return-to-go, state, or action). To obtain token embeddings, we learn a linear", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 72, + 506, + 85 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 506, + 85 + ], + "score": 1.0, + "content": "layer for each modality, which projects raw inputs to the embedding dimension, followed by layer", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 84, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 84, + 505, + 95 + ], + "score": 1.0, + "content": "normalization [18]. For environments with visual inputs, the state is fed into a convolutional encoder", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 95, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 95, + 505, + 106 + ], + "score": 1.0, + "content": "instead of a linear layer. Additionally, an embedding for each timestep is learned and added to each", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 105, + 505, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 505, + 118 + ], + "score": 1.0, + "content": "token – note this is different than the standard positional embedding used by transformers, as one", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 116, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 116, + 505, + 128 + ], + "score": 1.0, + "content": "timestep corresponds to three tokens. The tokens are then processed by a GPT [12] model, which", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 126, + 339, + 141 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 339, + 141 + ], + "score": 1.0, + "content": "predicts future action tokens via autoregressive modeling.", + "type": "text", + "cross_page": true + } + ], + "index": 5 + } + ], + "index": 44.5, + "bbox_fs": [ + 105, + 699, + 505, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 73, + 505, + 138 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 506, + 85 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 506, + 85 + ], + "score": 1.0, + "content": "layer for each modality, which projects raw inputs to the embedding dimension, followed by layer", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 84, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 84, + 505, + 95 + ], + "score": 1.0, + "content": "normalization [18]. For environments with visual inputs, the state is fed into a convolutional encoder", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 95, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 95, + 505, + 106 + ], + "score": 1.0, + "content": "instead of a linear layer. Additionally, an embedding for each timestep is learned and added to each", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 105, + 505, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 505, + 118 + ], + "score": 1.0, + "content": "token – note this is different than the standard positional embedding used by transformers, as one", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 116, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 116, + 505, + 128 + ], + "score": 1.0, + "content": "timestep corresponds to three tokens. The tokens are then processed by a GPT [12] model, which", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 126, + 339, + 141 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 339, + 141 + ], + "score": 1.0, + "content": "predicts future action tokens via autoregressive modeling.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 144, + 505, + 199 + ], + "lines": [ + { + "bbox": [ + 105, + 143, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 143, + 332, + 156 + ], + "score": 1.0, + "content": "Training. We sample minibatches of sequence length", + "type": "text" + }, + { + "bbox": [ + 333, + 144, + 343, + 154 + ], + "score": 0.81, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 344, + 143, + 505, + 156 + ], + "score": 1.0, + "content": "from the dataset. The prediction head", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 154, + 506, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 235, + 167 + ], + "score": 1.0, + "content": "corresponding to the input token", + "type": "text" + }, + { + "bbox": [ + 235, + 156, + 244, + 165 + ], + "score": 0.85, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 154, + 323, + 167 + ], + "score": 1.0, + "content": "is trained to predict", + "type": "text" + }, + { + "bbox": [ + 323, + 156, + 333, + 165 + ], + "score": 0.83, + "content": "a _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 154, + 506, + 167 + ], + "score": 1.0, + "content": "– either with cross-entropy loss for discrete", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 165, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 506, + 178 + ], + "score": 1.0, + "content": "actions or mean-squared error for continuous actions – and the losses for each timestep are averaged.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "score": 1.0, + "content": "We did not find predicting the states or returns-to-go to be necessary for good performance, although", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 188, + 464, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 464, + 200 + ], + "score": 1.0, + "content": "it is possible (as shown in Section 5.3) and would be an interesting study for future work.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 203, + 505, + 259 + ], + "lines": [ + { + "bbox": [ + 105, + 203, + 505, + 217 + ], + "spans": [ + { + "bbox": [ + 105, + 203, + 505, + 217 + ], + "score": 1.0, + "content": "Evaluation. During evaluation rollouts, we specify a target return based on our desired performance", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 214, + 506, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 506, + 228 + ], + "score": 1.0, + "content": "(e.g., specify maximum possible return to generate expert behavior) as well as the environment", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 226, + 505, + 238 + ], + "spans": [ + { + "bbox": [ + 106, + 226, + 505, + 238 + ], + "score": 1.0, + "content": "starting state, to initialize generation. After executing the generated action, we decrement the target", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 235, + 506, + 250 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 506, + 250 + ], + "score": 1.0, + "content": "return by the achieved reward and obtain the next state. We repeat this process of generating actions", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 247, + 447, + 260 + ], + "spans": [ + { + "bbox": [ + 106, + 247, + 447, + 260 + ], + "score": 1.0, + "content": "and applying them to obtain the next return-to-go and state until episode termination.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13 + }, + { + "type": "title", + "bbox": [ + 107, + 271, + 397, + 282 + ], + "lines": [ + { + "bbox": [ + 106, + 270, + 397, + 283 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 397, + 283 + ], + "score": 1.0, + "content": "Algorithm 1 Decision Transformer Pseudocode (for continuous actions)", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 291, + 474, + 346 + ], + "lines": [ + { + "bbox": [ + 105, + 290, + 436, + 302 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 436, + 302 + ], + "score": 1.0, + "content": "# R, s, a, t: returns -to -go , states , actions , or timesteps", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 299, + 474, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 299, + 474, + 310 + ], + "score": 1.0, + "content": "# K: context length ( length of each input to DecisionTransformer )", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 107, + 307, + 401, + 320 + ], + "spans": [ + { + "bbox": [ + 107, + 309, + 114, + 317 + ], + "score": 1.0, + "content": "#", + "type": "text" + }, + { + "bbox": [ + 115, + 307, + 401, + 320 + ], + "score": 1.0, + "content": "transformer : transformer with causal masking (GPT)", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 107, + 316, + 402, + 329 + ], + "spans": [ + { + "bbox": [ + 107, + 319, + 114, + 327 + ], + "score": 1.0, + "content": "#", + "type": "text" + }, + { + "bbox": [ + 118, + 316, + 402, + 329 + ], + "score": 1.0, + "content": "embed_s , embed_a , embed_R : linear embedding layers", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 324, + 375, + 339 + ], + "spans": [ + { + "bbox": [ + 106, + 326, + 114, + 336 + ], + "score": 1.0, + "content": "#", + "type": "text" + }, + { + "bbox": [ + 117, + 324, + 375, + 339 + ], + "score": 1.0, + "content": "embed_t : learned episode positional embedding", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 335, + 334, + 347 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 114, + 345 + ], + "score": 1.0, + "content": "#", + "type": "text" + }, + { + "bbox": [ + 117, + 335, + 334, + 347 + ], + "score": 1.0, + "content": "pred_a : linear action prediction layer", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 19.5 + }, + { + "type": "title", + "bbox": [ + 107, + 354, + 174, + 362 + ], + "lines": [ + { + "bbox": [ + 105, + 353, + 176, + 364 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 176, + 364 + ], + "score": 1.0, + "content": "# main model", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 110, + 363, + 307, + 372 + ], + "lines": [ + { + "bbox": [ + 107, + 362, + 309, + 374 + ], + "spans": [ + { + "bbox": [ + 107, + 362, + 309, + 374 + ], + "score": 1.0, + "content": "def DecisionTransformer (R , s , a , t ):", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 130, + 373, + 491, + 417 + ], + "lines": [ + { + "bbox": [ + 129, + 371, + 306, + 382 + ], + "spans": [ + { + "bbox": [ + 129, + 372, + 137, + 381 + ], + "score": 1.0, + "content": "#", + "type": "text" + }, + { + "bbox": [ + 140, + 371, + 306, + 382 + ], + "score": 1.0, + "content": "compute embeddings for tokens", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 128, + 379, + 491, + 392 + ], + "spans": [ + { + "bbox": [ + 128, + 380, + 207, + 391 + ], + "score": 1.0, + "content": "pos_embedding", + "type": "text" + }, + { + "bbox": [ + 207, + 382, + 216, + 389 + ], + "score": 0.51, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 380, + 278, + 391 + ], + "score": 1.0, + "content": "embed_t ( t )", + "type": "text" + }, + { + "bbox": [ + 285, + 379, + 369, + 392 + ], + "score": 1.0, + "content": "# per - timestep", + "type": "text" + }, + { + "bbox": [ + 372, + 380, + 491, + 392 + ], + "score": 1.0, + "content": "( note : not per - token )", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 127, + 388, + 357, + 401 + ], + "spans": [ + { + "bbox": [ + 127, + 388, + 196, + 401 + ], + "score": 1.0, + "content": "s_embedding", + "type": "text" + }, + { + "bbox": [ + 196, + 391, + 205, + 398 + ], + "score": 0.72, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 388, + 269, + 401 + ], + "score": 1.0, + "content": "embed_s ( s )", + "type": "text" + }, + { + "bbox": [ + 270, + 390, + 278, + 398 + ], + "score": 0.45, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 388, + 357, + 401 + ], + "score": 1.0, + "content": "pos_embedding", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 128, + 396, + 358, + 411 + ], + "spans": [ + { + "bbox": [ + 128, + 396, + 196, + 411 + ], + "score": 1.0, + "content": "a_embedding", + "type": "text" + }, + { + "bbox": [ + 196, + 399, + 205, + 407 + ], + "score": 0.8, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 396, + 269, + 411 + ], + "score": 1.0, + "content": "embed_a ( a )", + "type": "text" + }, + { + "bbox": [ + 270, + 399, + 278, + 407 + ], + "score": 0.51, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 396, + 358, + 411 + ], + "score": 1.0, + "content": "pos_embedding", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 128, + 406, + 358, + 420 + ], + "spans": [ + { + "bbox": [ + 128, + 406, + 196, + 420 + ], + "score": 1.0, + "content": "R_embedding", + "type": "text" + }, + { + "bbox": [ + 196, + 408, + 205, + 416 + ], + "score": 0.8, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 406, + 269, + 420 + ], + "score": 1.0, + "content": "embed_R ( R )", + "type": "text" + }, + { + "bbox": [ + 269, + 408, + 278, + 416 + ], + "score": 0.69, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 406, + 358, + 420 + ], + "score": 1.0, + "content": "pos_embedding", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 129, + 425, + 462, + 445 + ], + "lines": [ + { + "bbox": [ + 129, + 424, + 429, + 437 + ], + "spans": [ + { + "bbox": [ + 129, + 424, + 339, + 437 + ], + "score": 1.0, + "content": "# interleave tokens as (R_1 , s_1 , a_1", + "type": "text" + }, + { + "bbox": [ + 375, + 424, + 429, + 437 + ], + "score": 1.0, + "content": "R_K , s_K )", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 129, + 432, + 463, + 446 + ], + "spans": [ + { + "bbox": [ + 129, + 432, + 201, + 446 + ], + "score": 1.0, + "content": "input_embeds", + "type": "text" + }, + { + "bbox": [ + 201, + 435, + 211, + 443 + ], + "score": 0.77, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 432, + 463, + 446 + ], + "score": 1.0, + "content": "stack ( R_embedding , s_embedding , a_embedding )", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5 + }, + { + "type": "text", + "bbox": [ + 128, + 453, + 435, + 471 + ], + "lines": [ + { + "bbox": [ + 129, + 452, + 346, + 462 + ], + "spans": [ + { + "bbox": [ + 129, + 452, + 346, + 462 + ], + "score": 1.0, + "content": "# use transformer to get hidden states", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 129, + 461, + 434, + 471 + ], + "spans": [ + { + "bbox": [ + 129, + 461, + 207, + 471 + ], + "score": 1.0, + "content": "hidden_states", + "type": "text" + }, + { + "bbox": [ + 207, + 462, + 216, + 470 + ], + "score": 0.72, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 461, + 354, + 471 + ], + "score": 1.0, + "content": "transformer ( input_embeds", + "type": "text" + }, + { + "bbox": [ + 355, + 462, + 362, + 470 + ], + "score": 0.71, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 461, + 434, + 471 + ], + "score": 1.0, + "content": "input_embeds )", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 129, + 480, + 418, + 498 + ], + "lines": [ + { + "bbox": [ + 127, + 478, + 419, + 490 + ], + "spans": [ + { + "bbox": [ + 127, + 478, + 419, + 490 + ], + "score": 1.0, + "content": "# select hidden states for action prediction tokens", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 129, + 487, + 363, + 498 + ], + "spans": [ + { + "bbox": [ + 129, + 487, + 178, + 498 + ], + "score": 1.0, + "content": "a_hidden", + "type": "text" + }, + { + "bbox": [ + 179, + 489, + 188, + 497 + ], + "score": 0.75, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 487, + 363, + 498 + ], + "score": 1.0, + "content": "unstack ( hidden_states ). actions", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5 + }, + { + "type": "text", + "bbox": [ + 129, + 506, + 259, + 525 + ], + "lines": [ + { + "bbox": [ + 129, + 506, + 222, + 516 + ], + "spans": [ + { + "bbox": [ + 129, + 507, + 137, + 515 + ], + "score": 1.0, + "content": "#", + "type": "text" + }, + { + "bbox": [ + 138, + 506, + 222, + 516 + ], + "score": 1.0, + "content": "predict action", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 129, + 514, + 259, + 525 + ], + "spans": [ + { + "bbox": [ + 129, + 514, + 259, + 525 + ], + "score": 1.0, + "content": "return pred_a ( a_hidden )", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 107, + 534, + 192, + 542 + ], + "lines": [ + { + "bbox": [ + 106, + 531, + 194, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 194, + 545 + ], + "score": 1.0, + "content": "# training loop", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 108, + 542, + 486, + 579 + ], + "lines": [ + { + "bbox": [ + 106, + 540, + 452, + 553 + ], + "spans": [ + { + "bbox": [ + 106, + 540, + 286, + 553 + ], + "score": 1.0, + "content": "for (R , s , a , t ) in dataloader :", + "type": "text" + }, + { + "bbox": [ + 290, + 540, + 452, + 553 + ], + "score": 1.0, + "content": "# dims : ( batch_size , K, dim )", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 127, + 550, + 364, + 563 + ], + "spans": [ + { + "bbox": [ + 127, + 550, + 173, + 563 + ], + "score": 1.0, + "content": "a_preds", + "type": "text" + }, + { + "bbox": [ + 173, + 552, + 182, + 559 + ], + "score": 0.71, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 550, + 364, + 563 + ], + "score": 1.0, + "content": "DecisionTransformer (R , s , a , t )", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 128, + 558, + 487, + 571 + ], + "spans": [ + { + "bbox": [ + 128, + 558, + 156, + 571 + ], + "score": 1.0, + "content": "loss", + "type": "text" + }, + { + "bbox": [ + 157, + 561, + 165, + 568 + ], + "score": 0.66, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 558, + 270, + 571 + ], + "score": 1.0, + "content": "mean (( a_preds - a )", + "type": "text" + }, + { + "bbox": [ + 270, + 560, + 288, + 569 + ], + "score": 0.32, + "content": "* * 2", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 558, + 487, + 571 + ], + "score": 1.0, + "content": ") # L2 loss for continuous actions", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 129, + 568, + 447, + 580 + ], + "spans": [ + { + "bbox": [ + 129, + 568, + 447, + 580 + ], + "score": 1.0, + "content": "optimizer . zero_grad (); loss . backward (); optimizer . step ()", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40.5 + }, + { + "type": "text", + "bbox": [ + 108, + 587, + 203, + 596 + ], + "lines": [ + { + "bbox": [ + 107, + 585, + 204, + 598 + ], + "spans": [ + { + "bbox": [ + 107, + 585, + 204, + 598 + ], + "score": 1.0, + "content": "# evaluation loop", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 109, + 596, + 474, + 623 + ], + "lines": [ + { + "bbox": [ + 106, + 594, + 414, + 606 + ], + "spans": [ + { + "bbox": [ + 106, + 594, + 184, + 606 + ], + "score": 1.0, + "content": "target_return", + "type": "text" + }, + { + "bbox": [ + 184, + 596, + 204, + 605 + ], + "score": 0.37, + "content": "\\mathbf { \\lambda } = \\mathbf { \\bar { \\lambda } } 1", + "type": "inline_equation" + }, + { + "bbox": [ + 204, + 594, + 414, + 606 + ], + "score": 1.0, + "content": "# for instance , expert - level return", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 604, + 476, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 604, + 201, + 615 + ], + "score": 1.0, + "content": "R , s , a , t , done", + "type": "text" + }, + { + "bbox": [ + 201, + 605, + 210, + 613 + ], + "score": 0.68, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 604, + 476, + 615 + ], + "score": 1.0, + "content": "[ target_return ] , [ env . reset ()] , [] , [1] , False", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 107, + 613, + 408, + 625 + ], + "spans": [ + { + "bbox": [ + 107, + 614, + 194, + 623 + ], + "score": 1.0, + "content": "while not done :", + "type": "text" + }, + { + "bbox": [ + 202, + 614, + 211, + 622 + ], + "score": 1.0, + "content": "#", + "type": "text" + }, + { + "bbox": [ + 212, + 613, + 408, + 625 + ], + "score": 1.0, + "content": "autoregressive generation / sampling", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45 + }, + { + "type": "text", + "bbox": [ + 127, + 631, + 485, + 651 + ], + "lines": [ + { + "bbox": [ + 129, + 630, + 487, + 642 + ], + "spans": [ + { + "bbox": [ + 129, + 630, + 168, + 642 + ], + "score": 1.0, + "content": "action", + "type": "text" + }, + { + "bbox": [ + 168, + 633, + 177, + 640 + ], + "score": 0.74, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 177, + 630, + 379, + 642 + ], + "score": 1.0, + "content": "DecisionTransformer (R , s , a , t )[ -1]", + "type": "text" + }, + { + "bbox": [ + 385, + 630, + 487, + 642 + ], + "score": 1.0, + "content": "# for cts actions", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 128, + 640, + 334, + 651 + ], + "spans": [ + { + "bbox": [ + 128, + 640, + 229, + 651 + ], + "score": 1.0, + "content": "new_s , r , done , _", + "type": "text" + }, + { + "bbox": [ + 230, + 642, + 239, + 649 + ], + "score": 0.7, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 640, + 334, + 651 + ], + "score": 1.0, + "content": "env . step ( action )", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47.5 + }, + { + "type": "text", + "bbox": [ + 129, + 660, + 457, + 696 + ], + "lines": [ + { + "bbox": [ + 127, + 657, + 307, + 670 + ], + "spans": [ + { + "bbox": [ + 127, + 657, + 307, + 670 + ], + "score": 1.0, + "content": "# append new tokens to sequence", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 127, + 666, + 459, + 678 + ], + "spans": [ + { + "bbox": [ + 127, + 666, + 459, + 678 + ], + "score": 1.0, + "content": "R = R + [ R [ -1] - r] # decrement returns -to -go with reward", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 127, + 676, + 407, + 686 + ], + "spans": [ + { + "bbox": [ + 127, + 676, + 269, + 686 + ], + "score": 1.0, + "content": "s , a , t = s + [ new_s ] , a", + "type": "text" + }, + { + "bbox": [ + 269, + 677, + 278, + 685 + ], + "score": 0.28, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 676, + 407, + 686 + ], + "score": 1.0, + "content": "[ action ] , t + [ len ( R )]", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 127, + 683, + 454, + 698 + ], + "spans": [ + { + "bbox": [ + 127, + 683, + 190, + 698 + ], + "score": 1.0, + "content": "R , s , a , t", + "type": "text" + }, + { + "bbox": [ + 190, + 686, + 199, + 694 + ], + "score": 0.27, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 199, + 683, + 267, + 698 + ], + "score": 1.0, + "content": "R [ - K :] , ...", + "type": "text" + }, + { + "bbox": [ + 277, + 684, + 454, + 696 + ], + "score": 1.0, + "content": "# only keep context length of K", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 50.5 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 742, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 741, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 301, + 741, + 310, + 752 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 11, + "width": 9 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 73, + 505, + 138 + ], + "lines": [], + "index": 2.5, + "bbox_fs": [ + 105, + 72, + 506, + 141 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 144, + 505, + 199 + ], + "lines": [ + { + "bbox": [ + 105, + 143, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 143, + 332, + 156 + ], + "score": 1.0, + "content": "Training. We sample minibatches of sequence length", + "type": "text" + }, + { + "bbox": [ + 333, + 144, + 343, + 154 + ], + "score": 0.81, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 344, + 143, + 505, + 156 + ], + "score": 1.0, + "content": "from the dataset. The prediction head", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 154, + 506, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 235, + 167 + ], + "score": 1.0, + "content": "corresponding to the input token", + "type": "text" + }, + { + "bbox": [ + 235, + 156, + 244, + 165 + ], + "score": 0.85, + "content": "s _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 154, + 323, + 167 + ], + "score": 1.0, + "content": "is trained to predict", + "type": "text" + }, + { + "bbox": [ + 323, + 156, + 333, + 165 + ], + "score": 0.83, + "content": "a _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 154, + 506, + 167 + ], + "score": 1.0, + "content": "– either with cross-entropy loss for discrete", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 165, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 506, + 178 + ], + "score": 1.0, + "content": "actions or mean-squared error for continuous actions – and the losses for each timestep are averaged.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "score": 1.0, + "content": "We did not find predicting the states or returns-to-go to be necessary for good performance, although", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 188, + 464, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 464, + 200 + ], + "score": 1.0, + "content": "it is possible (as shown in Section 5.3) and would be an interesting study for future work.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 143, + 506, + 200 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 203, + 505, + 259 + ], + "lines": [ + { + "bbox": [ + 105, + 203, + 505, + 217 + ], + "spans": [ + { + "bbox": [ + 105, + 203, + 505, + 217 + ], + "score": 1.0, + "content": "Evaluation. During evaluation rollouts, we specify a target return based on our desired performance", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 214, + 506, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 506, + 228 + ], + "score": 1.0, + "content": "(e.g., specify maximum possible return to generate expert behavior) as well as the environment", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 226, + 505, + 238 + ], + "spans": [ + { + "bbox": [ + 106, + 226, + 505, + 238 + ], + "score": 1.0, + "content": "starting state, to initialize generation. After executing the generated action, we decrement the target", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 235, + 506, + 250 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 506, + 250 + ], + "score": 1.0, + "content": "return by the achieved reward and obtain the next state. We repeat this process of generating actions", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 247, + 447, + 260 + ], + "spans": [ + { + "bbox": [ + 106, + 247, + 447, + 260 + ], + "score": 1.0, + "content": "and applying them to obtain the next return-to-go and state until episode termination.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13, + "bbox_fs": [ + 105, + 203, + 506, + 260 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 271, + 397, + 282 + ], + "lines": [ + { + "bbox": [ + 106, + 270, + 397, + 283 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 397, + 283 + ], + "score": 1.0, + "content": "Algorithm 1 Decision Transformer Pseudocode (for continuous actions)", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "list", + "bbox": [ + 107, + 291, + 474, + 346 + ], + "lines": [ + { + "bbox": [ + 105, + 290, + 436, + 302 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 436, + 302 + ], + "score": 1.0, + "content": "# R, s, a, t: returns -to -go , states , actions , or timesteps", + "type": "text" + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 105, + 299, + 474, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 299, + 474, + 310 + ], + "score": 1.0, + "content": "# K: context length ( length of each input to DecisionTransformer )", + "type": "text" + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 107, + 307, + 401, + 320 + ], + "spans": [ + { + "bbox": [ + 107, + 309, + 114, + 317 + ], + "score": 1.0, + "content": "#", + "type": "text" + }, + { + "bbox": [ + 115, + 307, + 401, + 320 + ], + "score": 1.0, + "content": "transformer : transformer with causal masking (GPT)", + "type": "text" + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 107, + 316, + 402, + 329 + ], + "spans": [ + { + "bbox": [ + 107, + 319, + 114, + 327 + ], + "score": 1.0, + "content": "#", + "type": "text" + }, + { + "bbox": [ + 118, + 316, + 402, + 329 + ], + "score": 1.0, + "content": "embed_s , embed_a , embed_R : linear embedding layers", + "type": "text" + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 106, + 324, + 375, + 339 + ], + "spans": [ + { + "bbox": [ + 106, + 326, + 114, + 336 + ], + "score": 1.0, + "content": "#", + "type": "text" + }, + { + "bbox": [ + 117, + 324, + 375, + 339 + ], + "score": 1.0, + "content": "embed_t : learned episode positional embedding", + "type": "text" + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 106, + 335, + 334, + 347 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 114, + 345 + ], + "score": 1.0, + "content": "#", + "type": "text" + }, + { + "bbox": [ + 117, + 335, + 334, + 347 + ], + "score": 1.0, + "content": "pred_a : linear action prediction layer", + "type": "text" + } + ], + "index": 22, + "is_list_start_line": true + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 290, + 474, + 347 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 354, + 174, + 362 + ], + "lines": [ + { + "bbox": [ + 105, + 353, + 176, + 364 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 176, + 364 + ], + "score": 1.0, + "content": "# main model", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 110, + 363, + 307, + 372 + ], + "lines": [ + { + "bbox": [ + 107, + 362, + 309, + 374 + ], + "spans": [ + { + "bbox": [ + 107, + 362, + 309, + 374 + ], + "score": 1.0, + "content": "def DecisionTransformer (R , s , a , t ):", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24, + "bbox_fs": [ + 107, + 362, + 309, + 374 + ] + }, + { + "type": "list", + "bbox": [ + 130, + 373, + 491, + 417 + ], + "lines": [ + { + "bbox": [ + 129, + 371, + 306, + 382 + ], + "spans": [ + { + "bbox": [ + 129, + 372, + 137, + 381 + ], + "score": 1.0, + "content": "#", + "type": "text" + }, + { + "bbox": [ + 140, + 371, + 306, + 382 + ], + "score": 1.0, + "content": "compute embeddings for tokens", + "type": "text" + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 128, + 379, + 491, + 392 + ], + "spans": [ + { + "bbox": [ + 128, + 380, + 207, + 391 + ], + "score": 1.0, + "content": "pos_embedding", + "type": "text" + }, + { + "bbox": [ + 207, + 382, + 216, + 389 + ], + "score": 0.51, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 380, + 278, + 391 + ], + "score": 1.0, + "content": "embed_t ( t )", + "type": "text" + }, + { + "bbox": [ + 285, + 379, + 369, + 392 + ], + "score": 1.0, + "content": "# per - timestep", + "type": "text" + }, + { + "bbox": [ + 372, + 380, + 491, + 392 + ], + "score": 1.0, + "content": "( note : not per - token )", + "type": "text" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 388, + 357, + 401 + ], + "spans": [ + { + "bbox": [ + 127, + 388, + 196, + 401 + ], + "score": 1.0, + "content": "s_embedding", + "type": "text" + }, + { + "bbox": [ + 196, + 391, + 205, + 398 + ], + "score": 0.72, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 388, + 269, + 401 + ], + "score": 1.0, + "content": "embed_s ( s )", + "type": "text" + }, + { + "bbox": [ + 270, + 390, + 278, + 398 + ], + "score": 0.45, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 388, + 357, + 401 + ], + "score": 1.0, + "content": "pos_embedding", + "type": "text" + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 128, + 396, + 358, + 411 + ], + "spans": [ + { + "bbox": [ + 128, + 396, + 196, + 411 + ], + "score": 1.0, + "content": "a_embedding", + "type": "text" + }, + { + "bbox": [ + 196, + 399, + 205, + 407 + ], + "score": 0.8, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 396, + 269, + 411 + ], + "score": 1.0, + "content": "embed_a ( a )", + "type": "text" + }, + { + "bbox": [ + 270, + 399, + 278, + 407 + ], + "score": 0.51, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 396, + 358, + 411 + ], + "score": 1.0, + "content": "pos_embedding", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 128, + 406, + 358, + 420 + ], + "spans": [ + { + "bbox": [ + 128, + 406, + 196, + 420 + ], + "score": 1.0, + "content": "R_embedding", + "type": "text" + }, + { + "bbox": [ + 196, + 408, + 205, + 416 + ], + "score": 0.8, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 406, + 269, + 420 + ], + "score": 1.0, + "content": "embed_R ( R )", + "type": "text" + }, + { + "bbox": [ + 269, + 408, + 278, + 416 + ], + "score": 0.69, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 406, + 358, + 420 + ], + "score": 1.0, + "content": "pos_embedding", + "type": "text" + } + ], + "index": 29, + "is_list_start_line": true + } + ], + "index": 27, + "bbox_fs": [ + 127, + 371, + 491, + 420 + ] + }, + { + "type": "text", + "bbox": [ + 129, + 425, + 462, + 445 + ], + "lines": [ + { + "bbox": [ + 129, + 424, + 429, + 437 + ], + "spans": [ + { + "bbox": [ + 129, + 424, + 339, + 437 + ], + "score": 1.0, + "content": "# interleave tokens as (R_1 , s_1 , a_1", + "type": "text" + }, + { + "bbox": [ + 375, + 424, + 429, + 437 + ], + "score": 1.0, + "content": "R_K , s_K )", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 129, + 432, + 463, + 446 + ], + "spans": [ + { + "bbox": [ + 129, + 432, + 201, + 446 + ], + "score": 1.0, + "content": "input_embeds", + "type": "text" + }, + { + "bbox": [ + 201, + 435, + 211, + 443 + ], + "score": 0.77, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 432, + 463, + 446 + ], + "score": 1.0, + "content": "stack ( R_embedding , s_embedding , a_embedding )", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5, + "bbox_fs": [ + 129, + 424, + 463, + 446 + ] + }, + { + "type": "text", + "bbox": [ + 128, + 453, + 435, + 471 + ], + "lines": [ + { + "bbox": [ + 129, + 452, + 346, + 462 + ], + "spans": [ + { + "bbox": [ + 129, + 452, + 346, + 462 + ], + "score": 1.0, + "content": "# use transformer to get hidden states", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 129, + 461, + 434, + 471 + ], + "spans": [ + { + "bbox": [ + 129, + 461, + 207, + 471 + ], + "score": 1.0, + "content": "hidden_states", + "type": "text" + }, + { + "bbox": [ + 207, + 462, + 216, + 470 + ], + "score": 0.72, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 461, + 354, + 471 + ], + "score": 1.0, + "content": "transformer ( input_embeds", + "type": "text" + }, + { + "bbox": [ + 355, + 462, + 362, + 470 + ], + "score": 0.71, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 461, + 434, + 471 + ], + "score": 1.0, + "content": "input_embeds )", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5, + "bbox_fs": [ + 129, + 452, + 434, + 471 + ] + }, + { + "type": "text", + "bbox": [ + 129, + 480, + 418, + 498 + ], + "lines": [ + { + "bbox": [ + 127, + 478, + 419, + 490 + ], + "spans": [ + { + "bbox": [ + 127, + 478, + 419, + 490 + ], + "score": 1.0, + "content": "# select hidden states for action prediction tokens", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 129, + 487, + 363, + 498 + ], + "spans": [ + { + "bbox": [ + 129, + 487, + 178, + 498 + ], + "score": 1.0, + "content": "a_hidden", + "type": "text" + }, + { + "bbox": [ + 179, + 489, + 188, + 497 + ], + "score": 0.75, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 487, + 363, + 498 + ], + "score": 1.0, + "content": "unstack ( hidden_states ). actions", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5, + "bbox_fs": [ + 127, + 478, + 419, + 498 + ] + }, + { + "type": "text", + "bbox": [ + 129, + 506, + 259, + 525 + ], + "lines": [ + { + "bbox": [ + 129, + 506, + 222, + 516 + ], + "spans": [ + { + "bbox": [ + 129, + 507, + 137, + 515 + ], + "score": 1.0, + "content": "#", + "type": "text" + }, + { + "bbox": [ + 138, + 506, + 222, + 516 + ], + "score": 1.0, + "content": "predict action", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 129, + 514, + 259, + 525 + ], + "spans": [ + { + "bbox": [ + 129, + 514, + 259, + 525 + ], + "score": 1.0, + "content": "return pred_a ( a_hidden )", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5, + "bbox_fs": [ + 129, + 506, + 259, + 525 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 534, + 192, + 542 + ], + "lines": [ + { + "bbox": [ + 106, + 531, + 194, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 194, + 545 + ], + "score": 1.0, + "content": "# training loop", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38, + "bbox_fs": [ + 106, + 531, + 194, + 545 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 542, + 486, + 579 + ], + "lines": [ + { + "bbox": [ + 106, + 540, + 452, + 553 + ], + "spans": [ + { + "bbox": [ + 106, + 540, + 286, + 553 + ], + "score": 1.0, + "content": "for (R , s , a , t ) in dataloader :", + "type": "text" + }, + { + "bbox": [ + 290, + 540, + 452, + 553 + ], + "score": 1.0, + "content": "# dims : ( batch_size , K, dim )", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 127, + 550, + 364, + 563 + ], + "spans": [ + { + "bbox": [ + 127, + 550, + 173, + 563 + ], + "score": 1.0, + "content": "a_preds", + "type": "text" + }, + { + "bbox": [ + 173, + 552, + 182, + 559 + ], + "score": 0.71, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 550, + 364, + 563 + ], + "score": 1.0, + "content": "DecisionTransformer (R , s , a , t )", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 128, + 558, + 487, + 571 + ], + "spans": [ + { + "bbox": [ + 128, + 558, + 156, + 571 + ], + "score": 1.0, + "content": "loss", + "type": "text" + }, + { + "bbox": [ + 157, + 561, + 165, + 568 + ], + "score": 0.66, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 558, + 270, + 571 + ], + "score": 1.0, + "content": "mean (( a_preds - a )", + "type": "text" + }, + { + "bbox": [ + 270, + 560, + 288, + 569 + ], + "score": 0.32, + "content": "* * 2", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 558, + 487, + 571 + ], + "score": 1.0, + "content": ") # L2 loss for continuous actions", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 129, + 568, + 447, + 580 + ], + "spans": [ + { + "bbox": [ + 129, + 568, + 447, + 580 + ], + "score": 1.0, + "content": "optimizer . zero_grad (); loss . backward (); optimizer . step ()", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40.5, + "bbox_fs": [ + 106, + 540, + 487, + 580 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 587, + 203, + 596 + ], + "lines": [ + { + "bbox": [ + 107, + 585, + 204, + 598 + ], + "spans": [ + { + "bbox": [ + 107, + 585, + 204, + 598 + ], + "score": 1.0, + "content": "# evaluation loop", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 43, + "bbox_fs": [ + 107, + 585, + 204, + 598 + ] + }, + { + "type": "text", + "bbox": [ + 109, + 596, + 474, + 623 + ], + "lines": [ + { + "bbox": [ + 106, + 594, + 414, + 606 + ], + "spans": [ + { + "bbox": [ + 106, + 594, + 184, + 606 + ], + "score": 1.0, + "content": "target_return", + "type": "text" + }, + { + "bbox": [ + 184, + 596, + 204, + 605 + ], + "score": 0.37, + "content": "\\mathbf { \\lambda } = \\mathbf { \\bar { \\lambda } } 1", + "type": "inline_equation" + }, + { + "bbox": [ + 204, + 594, + 414, + 606 + ], + "score": 1.0, + "content": "# for instance , expert - level return", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 604, + 476, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 604, + 201, + 615 + ], + "score": 1.0, + "content": "R , s , a , t , done", + "type": "text" + }, + { + "bbox": [ + 201, + 605, + 210, + 613 + ], + "score": 0.68, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 604, + 476, + 615 + ], + "score": 1.0, + "content": "[ target_return ] , [ env . reset ()] , [] , [1] , False", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 107, + 613, + 408, + 625 + ], + "spans": [ + { + "bbox": [ + 107, + 614, + 194, + 623 + ], + "score": 1.0, + "content": "while not done :", + "type": "text" + }, + { + "bbox": [ + 202, + 614, + 211, + 622 + ], + "score": 1.0, + "content": "#", + "type": "text" + }, + { + "bbox": [ + 212, + 613, + 408, + 625 + ], + "score": 1.0, + "content": "autoregressive generation / sampling", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45, + "bbox_fs": [ + 106, + 594, + 476, + 625 + ] + }, + { + "type": "text", + "bbox": [ + 127, + 631, + 485, + 651 + ], + "lines": [ + { + "bbox": [ + 129, + 630, + 487, + 642 + ], + "spans": [ + { + "bbox": [ + 129, + 630, + 168, + 642 + ], + "score": 1.0, + "content": "action", + "type": "text" + }, + { + "bbox": [ + 168, + 633, + 177, + 640 + ], + "score": 0.74, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 177, + 630, + 379, + 642 + ], + "score": 1.0, + "content": "DecisionTransformer (R , s , a , t )[ -1]", + "type": "text" + }, + { + "bbox": [ + 385, + 630, + 487, + 642 + ], + "score": 1.0, + "content": "# for cts actions", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 128, + 640, + 334, + 651 + ], + "spans": [ + { + "bbox": [ + 128, + 640, + 229, + 651 + ], + "score": 1.0, + "content": "new_s , r , done , _", + "type": "text" + }, + { + "bbox": [ + 230, + 642, + 239, + 649 + ], + "score": 0.7, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 640, + 334, + 651 + ], + "score": 1.0, + "content": "env . step ( action )", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47.5, + "bbox_fs": [ + 128, + 630, + 487, + 651 + ] + }, + { + "type": "text", + "bbox": [ + 129, + 660, + 457, + 696 + ], + "lines": [ + { + "bbox": [ + 127, + 657, + 307, + 670 + ], + "spans": [ + { + "bbox": [ + 127, + 657, + 307, + 670 + ], + "score": 1.0, + "content": "# append new tokens to sequence", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 127, + 666, + 459, + 678 + ], + "spans": [ + { + "bbox": [ + 127, + 666, + 459, + 678 + ], + "score": 1.0, + "content": "R = R + [ R [ -1] - r] # decrement returns -to -go with reward", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 127, + 676, + 407, + 686 + ], + "spans": [ + { + "bbox": [ + 127, + 676, + 269, + 686 + ], + "score": 1.0, + "content": "s , a , t = s + [ new_s ] , a", + "type": "text" + }, + { + "bbox": [ + 269, + 677, + 278, + 685 + ], + "score": 0.28, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 676, + 407, + 686 + ], + "score": 1.0, + "content": "[ action ] , t + [ len ( R )]", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 127, + 683, + 454, + 698 + ], + "spans": [ + { + "bbox": [ + 127, + 683, + 190, + 698 + ], + "score": 1.0, + "content": "R , s , a , t", + "type": "text" + }, + { + "bbox": [ + 190, + 686, + 199, + 694 + ], + "score": 0.27, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 199, + 683, + 267, + 698 + ], + "score": 1.0, + "content": "R [ - K :] , ...", + "type": "text" + }, + { + "bbox": [ + 277, + 684, + 454, + 696 + ], + "score": 1.0, + "content": "# only keep context length of K", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 50.5, + "bbox_fs": [ + 127, + 657, + 459, + 698 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 105, + 67, + 505, + 168 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 105, + 67, + 505, + 168 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 67, + 505, + 168 + ], + "spans": [ + { + "bbox": [ + 105, + 67, + 505, + 168 + ], + "score": 0.955, + "type": "image", + "image_path": "6be7ce5512d46b7431e828fe71c83f457f669167743b6fc373ae4c4399521a50.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 105, + 67, + 505, + 100.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 105, + 100.66666666666666, + 505, + 134.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 105, + 134.33333333333331, + 505, + 167.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 186, + 506, + 219 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 186, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 505, + 199 + ], + "score": 1.0, + "content": "Figure 3: Results comparing Decision Transformer (ours) to TD learning (CQL) and behavior", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 196, + 506, + 209 + ], + "spans": [ + { + "bbox": [ + 105, + 196, + 506, + 209 + ], + "score": 1.0, + "content": "cloning across Atari, OpenAI Gym, and Minigrid. On a diverse set of tasks, Decision Transformer", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 208, + 344, + 221 + ], + "spans": [ + { + "bbox": [ + 106, + 208, + 344, + 221 + ], + "score": 1.0, + "content": "performs comparably or better than traditional approaches.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "title", + "bbox": [ + 107, + 228, + 323, + 242 + ], + "lines": [ + { + "bbox": [ + 105, + 227, + 324, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 227, + 324, + 244 + ], + "score": 1.0, + "content": "4 Evaluations on offline RL benchmarks", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 253, + 505, + 297 + ], + "lines": [ + { + "bbox": [ + 105, + 253, + 506, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 506, + 266 + ], + "score": 1.0, + "content": "In this section, we investigate if Decision Transformer can perform well compared to standard TD and", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 264, + 506, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 264, + 506, + 276 + ], + "score": 1.0, + "content": "imitation learning approaches for offline RL. TD learning algorithms represent the conventional state-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 276, + 506, + 287 + ], + "spans": [ + { + "bbox": [ + 106, + 276, + 506, + 287 + ], + "score": 1.0, + "content": "of-the-art, while imitation learning algorithms have similar formulations to Decision Transformer.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 286, + 444, + 298 + ], + "spans": [ + { + "bbox": [ + 106, + 286, + 444, + 298 + ], + "score": 1.0, + "content": "The exact algorithms depend on the environment but our motivations are as follows:", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 106, + 306, + 505, + 388 + ], + "lines": [ + { + "bbox": [ + 105, + 305, + 505, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 305, + 505, + 319 + ], + "score": 1.0, + "content": "• TD learning: most of these methods use an action-space constraint or value pessimism, and will", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 114, + 318, + 505, + 329 + ], + "spans": [ + { + "bbox": [ + 114, + 318, + 505, + 329 + ], + "score": 1.0, + "content": "be the most faithful comparison to Decision Transformer, representing standard RL methods. A", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 114, + 329, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 114, + 329, + 505, + 340 + ], + "score": 1.0, + "content": "state-of-the-art model-free method is Conservative Q-Learning (CQL) [17] which serves as our", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 114, + 339, + 505, + 352 + ], + "spans": [ + { + "bbox": [ + 114, + 339, + 505, + 352 + ], + "score": 1.0, + "content": "primary comparison. In addition, we also compare against other prior model-free RL algorithms", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 113, + 349, + 249, + 363 + ], + "spans": [ + { + "bbox": [ + 113, + 349, + 249, + 363 + ], + "score": 1.0, + "content": "like BEAR [19] and BRAC [20].", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 364, + 505, + 378 + ], + "spans": [ + { + "bbox": [ + 106, + 364, + 505, + 378 + ], + "score": 1.0, + "content": "• Imitation learning: this regime similarly uses supervised losses for training, rather than Bellman", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 114, + 376, + 493, + 389 + ], + "spans": [ + { + "bbox": [ + 114, + 376, + 493, + 389 + ], + "score": 1.0, + "content": "backups. We use behavior cloning here, and include a more detailed discussion in Section 5.1.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 106, + 396, + 505, + 441 + ], + "lines": [ + { + "bbox": [ + 105, + 396, + 505, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 505, + 409 + ], + "score": 1.0, + "content": "We evaluate on both discrete (Atari [13]) and continuous (OpenAI Gym [14]) control tasks. The", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 408, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 506, + 421 + ], + "score": 1.0, + "content": "former requires long-term credit assignment, while the latter requires fine-grained continuous control,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 419, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 106, + 419, + 505, + 431 + ], + "score": 1.0, + "content": "representing a diverse set of tasks. Our main results are summarized in Figure 3, where we show", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 429, + 342, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 342, + 442 + ], + "score": 1.0, + "content": "averaged expert normalized performance for each domain.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19.5 + }, + { + "type": "title", + "bbox": [ + 107, + 454, + 153, + 465 + ], + "lines": [ + { + "bbox": [ + 105, + 452, + 155, + 467 + ], + "spans": [ + { + "bbox": [ + 105, + 452, + 155, + 467 + ], + "score": 1.0, + "content": "4.1 Atari", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 106, + 473, + 505, + 551 + ], + "lines": [ + { + "bbox": [ + 105, + 473, + 506, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 506, + 487 + ], + "score": 1.0, + "content": "The Atari benchmark is challenging due to its high-dimensional visual inputs and difficulty of credit", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 485, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 506, + 496 + ], + "score": 1.0, + "content": "assignment arising from the delay between actions and resulting rewards. We evaluate our method on", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 495, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 120, + 506 + ], + "score": 0.84, + "content": "1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 120, + 495, + 506, + 509 + ], + "score": 1.0, + "content": "of all samples in the DQN-replay dataset as per Agarwal et al. [16], representing 500 thousand of", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 506, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 505, + 519 + ], + "score": 1.0, + "content": "the 50 million transitions observed by an online DQN agent [21] during training; we report the mean", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 517, + 504, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 517, + 504, + 529 + ], + "score": 1.0, + "content": "and standard deviation of 3 seeds. We normalize scores based on a professional gamer, following the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 528, + 506, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 506, + 542 + ], + "score": 1.0, + "content": "protocol of Hafner et al. [22], where 100 represents the professional gamer score and 0 represents a", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 538, + 169, + 553 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 169, + 553 + ], + "score": 1.0, + "content": "random policy.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 555, + 505, + 600 + ], + "lines": [ + { + "bbox": [ + 105, + 554, + 507, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 507, + 569 + ], + "score": 1.0, + "content": "We compare to CQL [17], REM [16], and QR-DQN [23] on four Atari tasks (Breakout, Qbert, Pong,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 566, + 506, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 452, + 579 + ], + "score": 1.0, + "content": "and Seaquest) that are evaluated in Agarwal et al. [16]. We use context lengths of", + "type": "text" + }, + { + "bbox": [ + 452, + 567, + 489, + 577 + ], + "score": 0.92, + "content": "K = 3 0", + "type": "inline_equation" + }, + { + "bbox": [ + 489, + 566, + 506, + 579 + ], + "score": 1.0, + "content": "for", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 578, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 232, + 590 + ], + "score": 1.0, + "content": "Decision Transformer (except", + "type": "text" + }, + { + "bbox": [ + 232, + 578, + 269, + 588 + ], + "score": 0.9, + "content": "K = 5 0", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 578, + 461, + 590 + ], + "score": 1.0, + "content": "for Pong); for results with different values of", + "type": "text" + }, + { + "bbox": [ + 462, + 578, + 472, + 587 + ], + "score": 0.81, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 578, + 505, + 590 + ], + "score": 1.0, + "content": "see the", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 588, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 505, + 601 + ], + "score": 1.0, + "content": "supplementary material. We also report the performance of behavior cloning (BC), which utilizes", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31.5 + }, + { + "type": "table", + "bbox": [ + 158, + 618, + 450, + 681 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 158, + 618, + 450, + 681 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 158, + 618, + 450, + 681 + ], + "spans": [ + { + "bbox": [ + 158, + 618, + 450, + 681 + ], + "score": 0.976, + "html": "
GameDT (Ours)CQLQR-DQNREMBC
Breakout267.5 ± 97.5211.121.132.1138.9 ± 61.7
Qbert15.1 ± 11.4104.21.71.417.3 ± 14.7
Pong106.1 ±8.1111.920.039.185.2 ± 20.0
Seaquest2.4± 0.71.71.41.02.1± 0.3
", + "type": "table", + "image_path": "c09a063a1b24fe2e8f3d693a626260be800c58ccba5fba82ee97e1f3080480bf.jpg" + } + ] + } + ], + "index": 35, + "virtual_lines": [ + { + "bbox": [ + 158, + 618, + 450, + 639.0 + ], + "spans": [], + "index": 34 + }, + { + "bbox": [ + 158, + 639.0, + 450, + 660.0 + ], + "spans": [], + "index": 35 + }, + { + "bbox": [ + 158, + 660.0, + 450, + 681.0 + ], + "spans": [], + "index": 36 + } + ] + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 686, + 505, + 721 + ], + "lines": [ + { + "bbox": [ + 105, + 686, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 288, + 699 + ], + "score": 1.0, + "content": "Table 1: Gamer-normalized scores for the", + "type": "text" + }, + { + "bbox": [ + 289, + 687, + 304, + 697 + ], + "score": 0.85, + "content": "1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 304, + 686, + 505, + 699 + ], + "score": 1.0, + "content": "DQN-replay Atari dataset. We report the mean", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 699, + 505, + 709 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 709 + ], + "score": 1.0, + "content": "and variance across 3 seeds. Best mean scores are highlighted in bold. Decision Transformer (DT)", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 708, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 504, + 722 + ], + "score": 1.0, + "content": "performs comparably to CQL on 3 out of 4 games, and outperforms other baselines in most games.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 740, + 310, + 753 + ], + "spans": [ + { + "bbox": [ + 301, + 740, + 310, + 753 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 105, + 67, + 505, + 168 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 105, + 67, + 505, + 168 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 67, + 505, + 168 + ], + "spans": [ + { + "bbox": [ + 105, + 67, + 505, + 168 + ], + "score": 0.955, + "type": "image", + "image_path": "6be7ce5512d46b7431e828fe71c83f457f669167743b6fc373ae4c4399521a50.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 105, + 67, + 505, + 100.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 105, + 100.66666666666666, + 505, + 134.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 105, + 134.33333333333331, + 505, + 167.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 186, + 506, + 219 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 186, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 505, + 199 + ], + "score": 1.0, + "content": "Figure 3: Results comparing Decision Transformer (ours) to TD learning (CQL) and behavior", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 196, + 506, + 209 + ], + "spans": [ + { + "bbox": [ + 105, + 196, + 506, + 209 + ], + "score": 1.0, + "content": "cloning across Atari, OpenAI Gym, and Minigrid. On a diverse set of tasks, Decision Transformer", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 208, + 344, + 221 + ], + "spans": [ + { + "bbox": [ + 106, + 208, + 344, + 221 + ], + "score": 1.0, + "content": "performs comparably or better than traditional approaches.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "title", + "bbox": [ + 107, + 228, + 323, + 242 + ], + "lines": [ + { + "bbox": [ + 105, + 227, + 324, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 227, + 324, + 244 + ], + "score": 1.0, + "content": "4 Evaluations on offline RL benchmarks", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 253, + 505, + 297 + ], + "lines": [ + { + "bbox": [ + 105, + 253, + 506, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 506, + 266 + ], + "score": 1.0, + "content": "In this section, we investigate if Decision Transformer can perform well compared to standard TD and", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 264, + 506, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 264, + 506, + 276 + ], + "score": 1.0, + "content": "imitation learning approaches for offline RL. TD learning algorithms represent the conventional state-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 276, + 506, + 287 + ], + "spans": [ + { + "bbox": [ + 106, + 276, + 506, + 287 + ], + "score": 1.0, + "content": "of-the-art, while imitation learning algorithms have similar formulations to Decision Transformer.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 286, + 444, + 298 + ], + "spans": [ + { + "bbox": [ + 106, + 286, + 444, + 298 + ], + "score": 1.0, + "content": "The exact algorithms depend on the environment but our motivations are as follows:", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 253, + 506, + 298 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 306, + 505, + 388 + ], + "lines": [ + { + "bbox": [ + 105, + 305, + 505, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 305, + 505, + 319 + ], + "score": 1.0, + "content": "• TD learning: most of these methods use an action-space constraint or value pessimism, and will", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 114, + 318, + 505, + 329 + ], + "spans": [ + { + "bbox": [ + 114, + 318, + 505, + 329 + ], + "score": 1.0, + "content": "be the most faithful comparison to Decision Transformer, representing standard RL methods. A", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 114, + 329, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 114, + 329, + 505, + 340 + ], + "score": 1.0, + "content": "state-of-the-art model-free method is Conservative Q-Learning (CQL) [17] which serves as our", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 114, + 339, + 505, + 352 + ], + "spans": [ + { + "bbox": [ + 114, + 339, + 505, + 352 + ], + "score": 1.0, + "content": "primary comparison. In addition, we also compare against other prior model-free RL algorithms", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 113, + 349, + 249, + 363 + ], + "spans": [ + { + "bbox": [ + 113, + 349, + 249, + 363 + ], + "score": 1.0, + "content": "like BEAR [19] and BRAC [20].", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 364, + 505, + 378 + ], + "spans": [ + { + "bbox": [ + 106, + 364, + 505, + 378 + ], + "score": 1.0, + "content": "• Imitation learning: this regime similarly uses supervised losses for training, rather than Bellman", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 114, + 376, + 493, + 389 + ], + "spans": [ + { + "bbox": [ + 114, + 376, + 493, + 389 + ], + "score": 1.0, + "content": "backups. We use behavior cloning here, and include a more detailed discussion in Section 5.1.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14, + "bbox_fs": [ + 105, + 305, + 505, + 389 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 396, + 505, + 441 + ], + "lines": [ + { + "bbox": [ + 105, + 396, + 505, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 505, + 409 + ], + "score": 1.0, + "content": "We evaluate on both discrete (Atari [13]) and continuous (OpenAI Gym [14]) control tasks. The", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 408, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 506, + 421 + ], + "score": 1.0, + "content": "former requires long-term credit assignment, while the latter requires fine-grained continuous control,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 419, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 106, + 419, + 505, + 431 + ], + "score": 1.0, + "content": "representing a diverse set of tasks. Our main results are summarized in Figure 3, where we show", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 429, + 342, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 342, + 442 + ], + "score": 1.0, + "content": "averaged expert normalized performance for each domain.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 396, + 506, + 442 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 454, + 153, + 465 + ], + "lines": [ + { + "bbox": [ + 105, + 452, + 155, + 467 + ], + "spans": [ + { + "bbox": [ + 105, + 452, + 155, + 467 + ], + "score": 1.0, + "content": "4.1 Atari", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 106, + 473, + 505, + 551 + ], + "lines": [ + { + "bbox": [ + 105, + 473, + 506, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 506, + 487 + ], + "score": 1.0, + "content": "The Atari benchmark is challenging due to its high-dimensional visual inputs and difficulty of credit", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 485, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 506, + 496 + ], + "score": 1.0, + "content": "assignment arising from the delay between actions and resulting rewards. We evaluate our method on", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 495, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 120, + 506 + ], + "score": 0.84, + "content": "1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 120, + 495, + 506, + 509 + ], + "score": 1.0, + "content": "of all samples in the DQN-replay dataset as per Agarwal et al. [16], representing 500 thousand of", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 506, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 505, + 519 + ], + "score": 1.0, + "content": "the 50 million transitions observed by an online DQN agent [21] during training; we report the mean", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 517, + 504, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 517, + 504, + 529 + ], + "score": 1.0, + "content": "and standard deviation of 3 seeds. We normalize scores based on a professional gamer, following the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 528, + 506, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 506, + 542 + ], + "score": 1.0, + "content": "protocol of Hafner et al. [22], where 100 represents the professional gamer score and 0 represents a", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 538, + 169, + 553 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 169, + 553 + ], + "score": 1.0, + "content": "random policy.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 26, + "bbox_fs": [ + 105, + 473, + 506, + 553 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 555, + 505, + 600 + ], + "lines": [ + { + "bbox": [ + 105, + 554, + 507, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 507, + 569 + ], + "score": 1.0, + "content": "We compare to CQL [17], REM [16], and QR-DQN [23] on four Atari tasks (Breakout, Qbert, Pong,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 566, + 506, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 452, + 579 + ], + "score": 1.0, + "content": "and Seaquest) that are evaluated in Agarwal et al. [16]. We use context lengths of", + "type": "text" + }, + { + "bbox": [ + 452, + 567, + 489, + 577 + ], + "score": 0.92, + "content": "K = 3 0", + "type": "inline_equation" + }, + { + "bbox": [ + 489, + 566, + 506, + 579 + ], + "score": 1.0, + "content": "for", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 578, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 232, + 590 + ], + "score": 1.0, + "content": "Decision Transformer (except", + "type": "text" + }, + { + "bbox": [ + 232, + 578, + 269, + 588 + ], + "score": 0.9, + "content": "K = 5 0", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 578, + 461, + 590 + ], + "score": 1.0, + "content": "for Pong); for results with different values of", + "type": "text" + }, + { + "bbox": [ + 462, + 578, + 472, + 587 + ], + "score": 0.81, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 578, + 505, + 590 + ], + "score": 1.0, + "content": "see the", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 588, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 505, + 601 + ], + "score": 1.0, + "content": "supplementary material. We also report the performance of behavior cloning (BC), which utilizes", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31.5, + "bbox_fs": [ + 105, + 554, + 507, + 601 + ] + }, + { + "type": "table", + "bbox": [ + 158, + 618, + 450, + 681 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 158, + 618, + 450, + 681 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 158, + 618, + 450, + 681 + ], + "spans": [ + { + "bbox": [ + 158, + 618, + 450, + 681 + ], + "score": 0.976, + "html": "
GameDT (Ours)CQLQR-DQNREMBC
Breakout267.5 ± 97.5211.121.132.1138.9 ± 61.7
Qbert15.1 ± 11.4104.21.71.417.3 ± 14.7
Pong106.1 ±8.1111.920.039.185.2 ± 20.0
Seaquest2.4± 0.71.71.41.02.1± 0.3
", + "type": "table", + "image_path": "c09a063a1b24fe2e8f3d693a626260be800c58ccba5fba82ee97e1f3080480bf.jpg" + } + ] + } + ], + "index": 35, + "virtual_lines": [ + { + "bbox": [ + 158, + 618, + 450, + 639.0 + ], + "spans": [], + "index": 34 + }, + { + "bbox": [ + 158, + 639.0, + 450, + 660.0 + ], + "spans": [], + "index": 35 + }, + { + "bbox": [ + 158, + 660.0, + 450, + 681.0 + ], + "spans": [], + "index": 36 + } + ] + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 686, + 505, + 721 + ], + "lines": [ + { + "bbox": [ + 105, + 686, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 288, + 699 + ], + "score": 1.0, + "content": "Table 1: Gamer-normalized scores for the", + "type": "text" + }, + { + "bbox": [ + 289, + 687, + 304, + 697 + ], + "score": 0.85, + "content": "1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 304, + 686, + 505, + 699 + ], + "score": 1.0, + "content": "DQN-replay Atari dataset. We report the mean", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 699, + 505, + 709 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 709 + ], + "score": 1.0, + "content": "and variance across 3 seeds. Best mean scores are highlighted in bold. Decision Transformer (DT)", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 708, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 504, + 722 + ], + "score": 1.0, + "content": "performs comparably to CQL on 3 out of 4 games, and outperforms other baselines in most games.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 686, + 505, + 722 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 73, + 505, + 117 + ], + "lines": [ + { + "bbox": [ + 105, + 73, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 73, + 505, + 86 + ], + "score": 1.0, + "content": "the same network architecture and hyperparameters as Decision Transformer but does not have", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 83, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 505, + 96 + ], + "score": 1.0, + "content": "return-to-go conditioning2. For CQL, REM, and QR-DQN baselines, we report numbers directly", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 94, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 506, + 107 + ], + "score": 1.0, + "content": "from the CQL paper. We show results in Table 1. Our method is competitive with CQL in 3 out of 4", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 105, + 415, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 415, + 119 + ], + "score": 1.0, + "content": "games and outperforms or matches REM, QR-DQN, and BC on all 4 games.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "title", + "bbox": [ + 107, + 129, + 188, + 142 + ], + "lines": [ + { + "bbox": [ + 105, + 128, + 190, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 190, + 145 + ], + "score": 1.0, + "content": "4.2 OpenAI Gym", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 106, + 150, + 505, + 205 + ], + "lines": [ + { + "bbox": [ + 106, + 151, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 106, + 151, + 505, + 161 + ], + "score": 1.0, + "content": "In this section, we consider the continuous control tasks from the D4RL benchmark [24]. We also", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 160, + 505, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 160, + 505, + 174 + ], + "score": 1.0, + "content": "consider a 2D reacher environment that is not part of the benchmark, and generate the datasets using", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 104, + 171, + 506, + 185 + ], + "spans": [ + { + "bbox": [ + 104, + 171, + 506, + 185 + ], + "score": 1.0, + "content": "a similar methodology to the D4RL benchmark. Reacher is a goal-conditioned task and has sparse", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 183, + 506, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 183, + 506, + 195 + ], + "score": 1.0, + "content": "rewards, so it represents a different setting than the standard locomotion environments (HalfCheetah,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 193, + 397, + 206 + ], + "spans": [ + { + "bbox": [ + 106, + 193, + 397, + 206 + ], + "score": 1.0, + "content": "Hopper, and Walker). The different dataset settings are described below.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 214, + 505, + 289 + ], + "lines": [ + { + "bbox": [ + 106, + 213, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 106, + 213, + 505, + 227 + ], + "score": 1.0, + "content": "1. Medium: 1 million timesteps generated by a “medium” policy that achieves approximately", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 118, + 224, + 275, + 238 + ], + "spans": [ + { + "bbox": [ + 118, + 224, + 275, + 238 + ], + "score": 1.0, + "content": "one-third the score of an expert policy.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 104, + 239, + 505, + 253 + ], + "spans": [ + { + "bbox": [ + 104, + 239, + 505, + 253 + ], + "score": 1.0, + "content": "2. Medium-Replay: the replay buffer of an agent trained to the performance of a medium policy", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 117, + 251, + 351, + 263 + ], + "spans": [ + { + "bbox": [ + 117, + 251, + 182, + 263 + ], + "score": 1.0, + "content": "(approximately", + "type": "text" + }, + { + "bbox": [ + 182, + 251, + 222, + 262 + ], + "score": 0.57, + "content": "2 5 \\mathrm { k } { - } 4 0 0 \\mathrm { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 251, + 351, + 263 + ], + "score": 1.0, + "content": "timesteps in our environments).", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 264, + 505, + 279 + ], + "spans": [ + { + "bbox": [ + 104, + 264, + 505, + 279 + ], + "score": 1.0, + "content": "3. Medium-Expert: 1 million timesteps generated by the medium policy concatenated with 1 million", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 118, + 277, + 281, + 290 + ], + "spans": [ + { + "bbox": [ + 118, + 277, + 281, + 290 + ], + "score": 1.0, + "content": "timesteps generated by an expert policy.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 107, + 296, + 505, + 363 + ], + "lines": [ + { + "bbox": [ + 106, + 297, + 506, + 308 + ], + "spans": [ + { + "bbox": [ + 106, + 297, + 506, + 308 + ], + "score": 1.0, + "content": "We compare to CQL [17], BEAR [19], BRAC [20], and AWR [25]. CQL represents the state-of-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 306, + 506, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 506, + 320 + ], + "score": 1.0, + "content": "the-art in model-free offline RL, an instantiation of TD learning with value pessimism. Score are", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 318, + 506, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 506, + 331 + ], + "score": 1.0, + "content": "normalized so that 100 represents an expert policy, as per Fu et al. [24]. CQL numbers are reported", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 330, + 505, + 342 + ], + "spans": [ + { + "bbox": [ + 106, + 330, + 505, + 342 + ], + "score": 1.0, + "content": "from the original paper; BC numbers are run by us; and the other methods are reported from the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 339, + 506, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 506, + 353 + ], + "score": 1.0, + "content": "D4RL paper. Our results are shown in Table 2. Decision Transformer achieves the highest scores in a", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 351, + 452, + 364 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 452, + 364 + ], + "score": 1.0, + "content": "majority of the tasks and is competitive with the state of the art in the remaining tasks.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18.5 + }, + { + "type": "table", + "bbox": [ + 116, + 373, + 493, + 551 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 116, + 373, + 493, + 551 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 116, + 373, + 493, + 551 + ], + "spans": [ + { + "bbox": [ + 116, + 373, + 493, + 551 + ], + "score": 0.984, + "html": "
DatasetEnvironmentDT (Ours)CQLBEARBRAC-vAWRBC
Medium-ExpertHalfCheetah86.8 ± 1.362.453.441.952.759.9
Medium-ExpertHopper107.6 ± 1.8111.096.30.827.179.6
Medium-ExpertWalker108.1 ±0.298.740.181.653.836.6
Medium-ExpertReacher89.1 ±1.330.6--173.3
MediumHalfCheetah42.6 ± 0.144.441.746.337.443.1
MediumHopper67.6 ± 1.058.052.131.135.963.9
MediumWalker74.0 ± 1.479.259.181.117.477.3
MediumReacher51.2 ± 3.426.011148.9
Medium-ReplayHalfCheetah36.6 ± 0.846.238.647.740.34.3
Medium-ReplayHopper82.7 ± 7.048.633.70.628.427.6
Medium-ReplayWalker66.6 ± 3.026.719.20.915.536.9
Medium-ReplayReacher18.0 ± 2.419.01115.4
Average (Without Reacher)74.763.948.236.934.346.4
Average (All Settings)69.254.21-147.7
", + "type": "table", + "image_path": "4058c54f4182eee535eaf3daa1c872ea7d3a5f74f8a6e9d88b74b1ad6b603bf9.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 116, + 373, + 493, + 432.3333333333333 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 116, + 432.3333333333333, + 493, + 491.66666666666663 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 116, + 491.66666666666663, + 493, + 551.0 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 104, + 558, + 504, + 581 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 558, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 505, + 571 + ], + "score": 1.0, + "content": "Table 2: Results for D4RL datasets4. We report the mean and variance for three seeds. Decision", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 569, + 425, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 569, + 425, + 581 + ], + "score": 1.0, + "content": "Transformer (DT) outperforms conventional RL algorithms on almost all tasks.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + } + ], + "index": 24.25 + }, + { + "type": "title", + "bbox": [ + 106, + 592, + 180, + 605 + ], + "lines": [ + { + "bbox": [ + 104, + 591, + 181, + 608 + ], + "spans": [ + { + "bbox": [ + 104, + 591, + 181, + 608 + ], + "score": 1.0, + "content": "5 Discussion", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "title", + "bbox": [ + 105, + 616, + 460, + 629 + ], + "lines": [ + { + "bbox": [ + 105, + 616, + 461, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 461, + 630 + ], + "score": 1.0, + "content": "5.1 Does Decision Transformer perform behavior cloning on a subset of the data?", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 637, + 505, + 692 + ], + "lines": [ + { + "bbox": [ + 106, + 637, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 505, + 649 + ], + "score": 1.0, + "content": "In this section, we seek to gain insight into whether Decision Transformer can be thought of as", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 648, + 506, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 506, + 660 + ], + "score": 1.0, + "content": "performing imitation learning on a subset of the data with a certain return. To investigate this, we", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 658, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 104, + 658, + 315, + 672 + ], + "score": 1.0, + "content": "propose a new method, Percentile Behavior Cloning", + "type": "text" + }, + { + "bbox": [ + 316, + 659, + 344, + 670 + ], + "score": 0.69, + "content": "( \\% \\mathrm { B C } )", + "type": "inline_equation" + }, + { + "bbox": [ + 344, + 658, + 505, + 672 + ], + "score": 1.0, + "content": ", where we run behavior cloning on only", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 670, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 136, + 683 + ], + "score": 1.0, + "content": "the top", + "type": "text" + }, + { + "bbox": [ + 137, + 670, + 155, + 681 + ], + "score": 0.89, + "content": "X \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 670, + 436, + 683 + ], + "score": 1.0, + "content": "of timesteps in the dataset, ordered by episode returns. The percentile", + "type": "text" + }, + { + "bbox": [ + 436, + 670, + 455, + 681 + ], + "score": 0.89, + "content": "X \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 455, + 670, + 505, + 683 + ], + "score": 1.0, + "content": "interpolates", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 680, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 195, + 694 + ], + "score": 1.0, + "content": "between standard BC", + "type": "text" + }, + { + "bbox": [ + 195, + 681, + 243, + 691 + ], + "score": 0.89, + "content": "X = 1 0 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 680, + 505, + 694 + ], + "score": 1.0, + "content": ") that trains on the entire dataset and only cloning the best observed", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 118, + 700, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 117, + 698, + 501, + 713 + ], + "spans": [ + { + "bbox": [ + 117, + 698, + 243, + 713 + ], + "score": 1.0, + "content": "2We also tried using an MLP with", + "type": "text" + }, + { + "bbox": [ + 244, + 701, + 270, + 710 + ], + "score": 0.89, + "content": "K = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 698, + 501, + 713 + ], + "score": 1.0, + "content": "as in prior work, but found this was worse than the transformer.", + "type": "text" + } + ] + }, + { + "bbox": [ + 117, + 709, + 505, + 725 + ], + "spans": [ + { + "bbox": [ + 117, + 709, + 505, + 725 + ], + "score": 1.0, + "content": "4Given that CQL is generally the strongest TD learning method, for Reacher we only run the CQL baseline.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 742, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 310, + 752 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 73, + 505, + 117 + ], + "lines": [ + { + "bbox": [ + 105, + 73, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 73, + 505, + 86 + ], + "score": 1.0, + "content": "the same network architecture and hyperparameters as Decision Transformer but does not have", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 83, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 505, + 96 + ], + "score": 1.0, + "content": "return-to-go conditioning2. For CQL, REM, and QR-DQN baselines, we report numbers directly", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 94, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 506, + 107 + ], + "score": 1.0, + "content": "from the CQL paper. We show results in Table 1. Our method is competitive with CQL in 3 out of 4", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 105, + 415, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 415, + 119 + ], + "score": 1.0, + "content": "games and outperforms or matches REM, QR-DQN, and BC on all 4 games.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5, + "bbox_fs": [ + 105, + 73, + 506, + 119 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 129, + 188, + 142 + ], + "lines": [ + { + "bbox": [ + 105, + 128, + 190, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 190, + 145 + ], + "score": 1.0, + "content": "4.2 OpenAI Gym", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 106, + 150, + 505, + 205 + ], + "lines": [ + { + "bbox": [ + 106, + 151, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 106, + 151, + 505, + 161 + ], + "score": 1.0, + "content": "In this section, we consider the continuous control tasks from the D4RL benchmark [24]. We also", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 160, + 505, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 160, + 505, + 174 + ], + "score": 1.0, + "content": "consider a 2D reacher environment that is not part of the benchmark, and generate the datasets using", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 104, + 171, + 506, + 185 + ], + "spans": [ + { + "bbox": [ + 104, + 171, + 506, + 185 + ], + "score": 1.0, + "content": "a similar methodology to the D4RL benchmark. Reacher is a goal-conditioned task and has sparse", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 183, + 506, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 183, + 506, + 195 + ], + "score": 1.0, + "content": "rewards, so it represents a different setting than the standard locomotion environments (HalfCheetah,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 193, + 397, + 206 + ], + "spans": [ + { + "bbox": [ + 106, + 193, + 397, + 206 + ], + "score": 1.0, + "content": "Hopper, and Walker). The different dataset settings are described below.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 7, + "bbox_fs": [ + 104, + 151, + 506, + 206 + ] + }, + { + "type": "list", + "bbox": [ + 107, + 214, + 505, + 289 + ], + "lines": [ + { + "bbox": [ + 106, + 213, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 106, + 213, + 505, + 227 + ], + "score": 1.0, + "content": "1. Medium: 1 million timesteps generated by a “medium” policy that achieves approximately", + "type": "text" + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 118, + 224, + 275, + 238 + ], + "spans": [ + { + "bbox": [ + 118, + 224, + 275, + 238 + ], + "score": 1.0, + "content": "one-third the score of an expert policy.", + "type": "text" + } + ], + "index": 11, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 239, + 505, + 253 + ], + "spans": [ + { + "bbox": [ + 104, + 239, + 505, + 253 + ], + "score": 1.0, + "content": "2. Medium-Replay: the replay buffer of an agent trained to the performance of a medium policy", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 117, + 251, + 351, + 263 + ], + "spans": [ + { + "bbox": [ + 117, + 251, + 182, + 263 + ], + "score": 1.0, + "content": "(approximately", + "type": "text" + }, + { + "bbox": [ + 182, + 251, + 222, + 262 + ], + "score": 0.57, + "content": "2 5 \\mathrm { k } { - } 4 0 0 \\mathrm { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 251, + 351, + 263 + ], + "score": 1.0, + "content": "timesteps in our environments).", + "type": "text" + } + ], + "index": 13, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 264, + 505, + 279 + ], + "spans": [ + { + "bbox": [ + 104, + 264, + 505, + 279 + ], + "score": 1.0, + "content": "3. Medium-Expert: 1 million timesteps generated by the medium policy concatenated with 1 million", + "type": "text" + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 118, + 277, + 281, + 290 + ], + "spans": [ + { + "bbox": [ + 118, + 277, + 281, + 290 + ], + "score": 1.0, + "content": "timesteps generated by an expert policy.", + "type": "text" + } + ], + "index": 15, + "is_list_end_line": true + } + ], + "index": 12.5, + "bbox_fs": [ + 104, + 213, + 505, + 290 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 296, + 505, + 363 + ], + "lines": [ + { + "bbox": [ + 106, + 297, + 506, + 308 + ], + "spans": [ + { + "bbox": [ + 106, + 297, + 506, + 308 + ], + "score": 1.0, + "content": "We compare to CQL [17], BEAR [19], BRAC [20], and AWR [25]. CQL represents the state-of-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 306, + 506, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 506, + 320 + ], + "score": 1.0, + "content": "the-art in model-free offline RL, an instantiation of TD learning with value pessimism. Score are", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 318, + 506, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 506, + 331 + ], + "score": 1.0, + "content": "normalized so that 100 represents an expert policy, as per Fu et al. [24]. CQL numbers are reported", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 330, + 505, + 342 + ], + "spans": [ + { + "bbox": [ + 106, + 330, + 505, + 342 + ], + "score": 1.0, + "content": "from the original paper; BC numbers are run by us; and the other methods are reported from the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 339, + 506, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 506, + 353 + ], + "score": 1.0, + "content": "D4RL paper. Our results are shown in Table 2. Decision Transformer achieves the highest scores in a", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 351, + 452, + 364 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 452, + 364 + ], + "score": 1.0, + "content": "majority of the tasks and is competitive with the state of the art in the remaining tasks.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18.5, + "bbox_fs": [ + 105, + 297, + 506, + 364 + ] + }, + { + "type": "table", + "bbox": [ + 116, + 373, + 493, + 551 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 116, + 373, + 493, + 551 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 116, + 373, + 493, + 551 + ], + "spans": [ + { + "bbox": [ + 116, + 373, + 493, + 551 + ], + "score": 0.984, + "html": "
DatasetEnvironmentDT (Ours)CQLBEARBRAC-vAWRBC
Medium-ExpertHalfCheetah86.8 ± 1.362.453.441.952.759.9
Medium-ExpertHopper107.6 ± 1.8111.096.30.827.179.6
Medium-ExpertWalker108.1 ±0.298.740.181.653.836.6
Medium-ExpertReacher89.1 ±1.330.6--173.3
MediumHalfCheetah42.6 ± 0.144.441.746.337.443.1
MediumHopper67.6 ± 1.058.052.131.135.963.9
MediumWalker74.0 ± 1.479.259.181.117.477.3
MediumReacher51.2 ± 3.426.011148.9
Medium-ReplayHalfCheetah36.6 ± 0.846.238.647.740.34.3
Medium-ReplayHopper82.7 ± 7.048.633.70.628.427.6
Medium-ReplayWalker66.6 ± 3.026.719.20.915.536.9
Medium-ReplayReacher18.0 ± 2.419.01115.4
Average (Without Reacher)74.763.948.236.934.346.4
Average (All Settings)69.254.21-147.7
", + "type": "table", + "image_path": "4058c54f4182eee535eaf3daa1c872ea7d3a5f74f8a6e9d88b74b1ad6b603bf9.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 116, + 373, + 493, + 432.3333333333333 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 116, + 432.3333333333333, + 493, + 491.66666666666663 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 116, + 491.66666666666663, + 493, + 551.0 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 104, + 558, + 504, + 581 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 558, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 505, + 571 + ], + "score": 1.0, + "content": "Table 2: Results for D4RL datasets4. We report the mean and variance for three seeds. Decision", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 569, + 425, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 569, + 425, + 581 + ], + "score": 1.0, + "content": "Transformer (DT) outperforms conventional RL algorithms on almost all tasks.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + } + ], + "index": 24.25 + }, + { + "type": "title", + "bbox": [ + 106, + 592, + 180, + 605 + ], + "lines": [ + { + "bbox": [ + 104, + 591, + 181, + 608 + ], + "spans": [ + { + "bbox": [ + 104, + 591, + 181, + 608 + ], + "score": 1.0, + "content": "5 Discussion", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "title", + "bbox": [ + 105, + 616, + 460, + 629 + ], + "lines": [ + { + "bbox": [ + 105, + 616, + 461, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 461, + 630 + ], + "score": 1.0, + "content": "5.1 Does Decision Transformer perform behavior cloning on a subset of the data?", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 637, + 505, + 692 + ], + "lines": [ + { + "bbox": [ + 106, + 637, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 505, + 649 + ], + "score": 1.0, + "content": "In this section, we seek to gain insight into whether Decision Transformer can be thought of as", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 648, + 506, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 506, + 660 + ], + "score": 1.0, + "content": "performing imitation learning on a subset of the data with a certain return. To investigate this, we", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 658, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 104, + 658, + 315, + 672 + ], + "score": 1.0, + "content": "propose a new method, Percentile Behavior Cloning", + "type": "text" + }, + { + "bbox": [ + 316, + 659, + 344, + 670 + ], + "score": 0.69, + "content": "( \\% \\mathrm { B C } )", + "type": "inline_equation" + }, + { + "bbox": [ + 344, + 658, + 505, + 672 + ], + "score": 1.0, + "content": ", where we run behavior cloning on only", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 670, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 136, + 683 + ], + "score": 1.0, + "content": "the top", + "type": "text" + }, + { + "bbox": [ + 137, + 670, + 155, + 681 + ], + "score": 0.89, + "content": "X \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 670, + 436, + 683 + ], + "score": 1.0, + "content": "of timesteps in the dataset, ordered by episode returns. The percentile", + "type": "text" + }, + { + "bbox": [ + 436, + 670, + 455, + 681 + ], + "score": 0.89, + "content": "X \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 455, + 670, + 505, + 683 + ], + "score": 1.0, + "content": "interpolates", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 680, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 195, + 694 + ], + "score": 1.0, + "content": "between standard BC", + "type": "text" + }, + { + "bbox": [ + 195, + 681, + 243, + 691 + ], + "score": 0.89, + "content": "X = 1 0 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 680, + 505, + 694 + ], + "score": 1.0, + "content": ") that trains on the entire dataset and only cloning the best observed", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 230, + 506, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 230, + 148, + 244 + ], + "score": 1.0, + "content": "trajectory", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 149, + 231, + 189, + 242 + ], + "score": 0.89, + "content": "( X 0 \\%", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 189, + 230, + 506, + 244 + ], + "score": 1.0, + "content": "), trading off between better generalization by training on more data with training", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 241, + 369, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 369, + 254 + ], + "score": 1.0, + "content": "a specialized model that focuses on a desirable subset of the data.", + "type": "text", + "cross_page": true + } + ], + "index": 5 + } + ], + "index": 31, + "bbox_fs": [ + 104, + 637, + 506, + 694 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 70, + 503, + 194 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 70, + 503, + 194 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 70, + 503, + 194 + ], + "spans": [ + { + "bbox": [ + 106, + 70, + 503, + 194 + ], + "score": 0.983, + "html": "
DatasetEnvironmentDT (Ours)10%BC25%BC40%BC100%BCCQL
MediumHalfCheetah42.6 ± 0.142.943.043.143.144.4
MediumHopper67.6 ± 1.065.965.265.363.958.0
MediumWalker74.0 ± 1.478.880.978.877.379.2
MediumReacher51.2 ± 3.451.048.958.258.426.0
Medium-ReplayHalfCheetah36.6 ± 0.840.840.941.14.346.2
Medium-ReplayHopper82.7 ± 7.070.658.631.027.648.6
Medium-ReplayWalker66.6 ± 3.070.467.867.236.926.7
Medium-ReplayReacher18.0 ± 2.433.116.210.75.419.0
Average56.156.752.749.439.543.5
", + "type": "table", + "image_path": "30e324cb7f286a944c6ae8968e8be730623cd41a282d871352fae6a88e317a56.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 70, + 503, + 111.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 111.33333333333334, + 503, + 152.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 152.66666666666669, + 503, + 194.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 105, + 199, + 504, + 210 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 197, + 502, + 213 + ], + "spans": [ + { + "bbox": [ + 104, + 197, + 474, + 213 + ], + "score": 1.0, + "content": "Table 3: Comparison between Decision Transformer (DT) and Percentile Behavior Cloning", + "type": "text" + }, + { + "bbox": [ + 474, + 199, + 502, + 210 + ], + "score": 0.46, + "content": "( \\% \\mathrm { B C } )", + "type": "inline_equation" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "text", + "bbox": [ + 106, + 231, + 504, + 253 + ], + "lines": [ + { + "bbox": [ + 105, + 230, + 506, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 230, + 148, + 244 + ], + "score": 1.0, + "content": "trajectory", + "type": "text" + }, + { + "bbox": [ + 149, + 231, + 189, + 242 + ], + "score": 0.89, + "content": "( X 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 230, + 506, + 244 + ], + "score": 1.0, + "content": "), trading off between better generalization by training on more data with training", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 241, + 369, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 369, + 254 + ], + "score": 1.0, + "content": "a specialized model that focuses on a desirable subset of the data.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 106, + 258, + 505, + 335 + ], + "lines": [ + { + "bbox": [ + 105, + 257, + 506, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 257, + 235, + 271 + ], + "score": 1.0, + "content": "We show full results comparing", + "type": "text" + }, + { + "bbox": [ + 236, + 258, + 259, + 268 + ], + "score": 0.78, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 257, + 506, + 271 + ], + "score": 1.0, + "content": "to Decision Transformer and CQL in Table 3, sweeping over", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 107, + 268, + 506, + 282 + ], + "spans": [ + { + "bbox": [ + 107, + 268, + 225, + 281 + ], + "score": 0.29, + "content": "X \\in [ 1 0 \\% , 2 5 \\% , 4 0 \\% , 1 \\dot { 0 } \\dot { 0 } \\% ]", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 268, + 311, + 282 + ], + "score": 1.0, + "content": ". Note that while both", + "type": "text" + }, + { + "bbox": [ + 312, + 269, + 335, + 280 + ], + "score": 0.72, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 268, + 506, + 282 + ], + "score": 1.0, + "content": "and DT introduce hyperparameters, returns", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 280, + 505, + 293 + ], + "spans": [ + { + "bbox": [ + 106, + 280, + 505, + 293 + ], + "score": 1.0, + "content": "are human interpretable and it is relatively natural for humans to specify a desired return compared to", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 291, + 505, + 302 + ], + "spans": [ + { + "bbox": [ + 106, + 291, + 505, + 302 + ], + "score": 1.0, + "content": "choosing an optimal subset for cloning. When data is plentiful – as in the D4RL regime – we find", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 301, + 505, + 314 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 129, + 312 + ], + "score": 0.76, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 301, + 505, + 314 + ], + "score": 1.0, + "content": "can match or beat other offline RL methods. On most environments, Decision Transformer is", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 312, + 506, + 325 + ], + "spans": [ + { + "bbox": [ + 106, + 312, + 289, + 325 + ], + "score": 1.0, + "content": "competitive with the performance of the best", + "type": "text" + }, + { + "bbox": [ + 290, + 313, + 313, + 323 + ], + "score": 0.66, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 312, + 506, + 325 + ], + "score": 1.0, + "content": ", indicating it can hone in on a particular subset", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 325, + 293, + 335 + ], + "spans": [ + { + "bbox": [ + 106, + 325, + 293, + 335 + ], + "score": 1.0, + "content": "after training on the entire dataset distribution.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 107, + 339, + 505, + 417 + ], + "lines": [ + { + "bbox": [ + 106, + 340, + 505, + 352 + ], + "spans": [ + { + "bbox": [ + 106, + 340, + 415, + 352 + ], + "score": 1.0, + "content": "In contrast, when we study low data regimes – such as Atari, where we use", + "type": "text" + }, + { + "bbox": [ + 416, + 340, + 430, + 351 + ], + "score": 0.86, + "content": "1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 431, + 340, + 505, + 352 + ], + "score": 1.0, + "content": "of a replay buffer", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 351, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 170, + 363 + ], + "score": 1.0, + "content": "as the dataset –", + "type": "text" + }, + { + "bbox": [ + 170, + 351, + 196, + 361 + ], + "score": 0.52, + "content": "\\mathbf { \\nabla } \\cdot \\% \\mathbf { B } \\mathbf { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 351, + 505, + 363 + ], + "score": 1.0, + "content": "is weak (shown in Table 4). This suggests that in scenarios with relatively", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 361, + 505, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 354, + 374 + ], + "score": 1.0, + "content": "low amounts of data, Decision Transformer can outperform", + "type": "text" + }, + { + "bbox": [ + 355, + 362, + 379, + 372 + ], + "score": 0.79, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 361, + 505, + 374 + ], + "score": 1.0, + "content": "by using all trajectories in the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 371, + 506, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 506, + 387 + ], + "score": 1.0, + "content": "dataset to improve generalization, even if those trajectories are dissimilar from the return conditioning", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 383, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 505, + 397 + ], + "score": 1.0, + "content": "target. Our results indicate that Decision Transformer can be more effective than simply performing", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 395, + 505, + 406 + ], + "spans": [ + { + "bbox": [ + 106, + 395, + 505, + 406 + ], + "score": 1.0, + "content": "imitation learning on a subset of the dataset. On the tasks we considered, Decision Transformer either", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 405, + 504, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 237, + 418 + ], + "score": 1.0, + "content": "outperforms or is competitive to", + "type": "text" + }, + { + "bbox": [ + 237, + 406, + 260, + 416 + ], + "score": 0.74, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 405, + 504, + 418 + ], + "score": 1.0, + "content": ", without the confound of having to select the optimal subset.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 16 + }, + { + "type": "table", + "bbox": [ + 133, + 427, + 475, + 491 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 133, + 427, + 475, + 491 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 133, + 427, + 475, + 491 + ], + "spans": [ + { + "bbox": [ + 133, + 427, + 475, + 491 + ], + "score": 0.979, + "html": "
GameDT (Ours)10%BC25%BC40%BC100%BC
Breakout267.5 ± 97.528.5±8.273.5 ± 6.4108.2 ± 67.5138.9 ± 61.7
Qbert15.1 ± 11.46.6 ± 1.716.0 ± 13.811.8± 5.817.3 ± 14.7
Pong106.1 ±8.12.5± 0.213.3 ± 2.772.7 ± 13.385.2 ± 20.0
Seaquest2.4 ± 0.71.1 ± 0.21.1 ± 0.21.6 ± 0.42.1 ± 0.3
", + "type": "table", + "image_path": "f7b3e0dda54d8e04dec597f56f451d1866f4fd896d6e53dc669b8062bb2381af.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 133, + 427, + 475, + 448.3333333333333 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 133, + 448.3333333333333, + 475, + 469.66666666666663 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 133, + 469.66666666666663, + 475, + 490.99999999999994 + ], + "spans": [], + "index": 22 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 106, + 495, + 505, + 518 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 494, + 505, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 140, + 508 + ], + "score": 1.0, + "content": "Table 4:", + "type": "text" + }, + { + "bbox": [ + 140, + 496, + 163, + 506 + ], + "score": 0.32, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 494, + 505, + 508 + ], + "score": 1.0, + "content": "scores for Atari. We report the mean and variance across 3 seeds. Decision Transformer", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 506, + 325, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 238, + 519 + ], + "score": 1.0, + "content": "(DT) outperforms all versions of", + "type": "text" + }, + { + "bbox": [ + 239, + 507, + 262, + 517 + ], + "score": 0.5, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 506, + 325, + 519 + ], + "score": 1.0, + "content": "in most games.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5 + } + ], + "index": 22.25 + }, + { + "type": "title", + "bbox": [ + 108, + 536, + 433, + 549 + ], + "lines": [ + { + "bbox": [ + 106, + 537, + 434, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 434, + 550 + ], + "score": 1.0, + "content": "5.2 How well does Decision Transformer model the distribution of returns?", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 557, + 505, + 656 + ], + "lines": [ + { + "bbox": [ + 106, + 558, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 558, + 505, + 569 + ], + "score": 1.0, + "content": "We evaluate the ability of Decision Transformer to understand return-to-go tokens by varying the", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 568, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 506, + 581 + ], + "score": 1.0, + "content": "desired target return over a wide range – evaluating the multi-task distribution modeling capability of", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 579, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 506, + 592 + ], + "score": 1.0, + "content": "transformers. Figure 4 shows the average sampled return accumulated by the agent over the course of", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 589, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 505, + 603 + ], + "score": 1.0, + "content": "the evaluation episode for varying values of target return. On every task, the desired target returns", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 601, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 506, + 614 + ], + "score": 1.0, + "content": "and the true observed returns are highly correlated. On some tasks like Pong, HalfCheetah and", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 612, + 506, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 506, + 625 + ], + "score": 1.0, + "content": "Walker, Decision Transformer generates trajectories that almost perfectly match the desired returns", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 622, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 106, + 622, + 505, + 636 + ], + "score": 1.0, + "content": "(as indicated by the overlap with the oracle line). Furthermore, on some Atari tasks like Seaquest, we", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "score": 1.0, + "content": "can prompt the Decision Transformer with higher returns than the maximum episode return available", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 645, + 486, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 645, + 486, + 657 + ], + "score": 1.0, + "content": "in the dataset, demonstrating that Decision Transformer is sometimes capable of extrapolation.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 30 + }, + { + "type": "title", + "bbox": [ + 108, + 668, + 447, + 681 + ], + "lines": [ + { + "bbox": [ + 105, + 668, + 449, + 682 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 449, + 682 + ], + "score": 1.0, + "content": "5.3 Does Decision Transformer perform effective long-term credit assignment?", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 108, + 689, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 689, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 505, + 701 + ], + "score": 1.0, + "content": "To evaluate long-term credit assignment capabilities of our model, we consider a variant of the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 505, + 712 + ], + "score": 1.0, + "content": "Key-to-Door environment proposed in Mesnard et al. [15]. This is a grid-based environment with a", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "sequence of three phases: (1) in the first phase, the agent is placed in a room with a key; (2) then, the", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 70, + 503, + 194 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 70, + 503, + 194 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 70, + 503, + 194 + ], + "spans": [ + { + "bbox": [ + 106, + 70, + 503, + 194 + ], + "score": 0.983, + "html": "
DatasetEnvironmentDT (Ours)10%BC25%BC40%BC100%BCCQL
MediumHalfCheetah42.6 ± 0.142.943.043.143.144.4
MediumHopper67.6 ± 1.065.965.265.363.958.0
MediumWalker74.0 ± 1.478.880.978.877.379.2
MediumReacher51.2 ± 3.451.048.958.258.426.0
Medium-ReplayHalfCheetah36.6 ± 0.840.840.941.14.346.2
Medium-ReplayHopper82.7 ± 7.070.658.631.027.648.6
Medium-ReplayWalker66.6 ± 3.070.467.867.236.926.7
Medium-ReplayReacher18.0 ± 2.433.116.210.75.419.0
Average56.156.752.749.439.543.5
", + "type": "table", + "image_path": "30e324cb7f286a944c6ae8968e8be730623cd41a282d871352fae6a88e317a56.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 70, + 503, + 111.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 111.33333333333334, + 503, + 152.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 152.66666666666669, + 503, + 194.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 105, + 199, + 504, + 210 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 197, + 502, + 213 + ], + "spans": [ + { + "bbox": [ + 104, + 197, + 474, + 213 + ], + "score": 1.0, + "content": "Table 3: Comparison between Decision Transformer (DT) and Percentile Behavior Cloning", + "type": "text" + }, + { + "bbox": [ + 474, + 199, + 502, + 210 + ], + "score": 0.46, + "content": "( \\% \\mathrm { B C } )", + "type": "inline_equation" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "text", + "bbox": [ + 106, + 231, + 504, + 253 + ], + "lines": [], + "index": 4.5, + "bbox_fs": [ + 105, + 230, + 506, + 254 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 258, + 505, + 335 + ], + "lines": [ + { + "bbox": [ + 105, + 257, + 506, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 257, + 235, + 271 + ], + "score": 1.0, + "content": "We show full results comparing", + "type": "text" + }, + { + "bbox": [ + 236, + 258, + 259, + 268 + ], + "score": 0.78, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 257, + 506, + 271 + ], + "score": 1.0, + "content": "to Decision Transformer and CQL in Table 3, sweeping over", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 107, + 268, + 506, + 282 + ], + "spans": [ + { + "bbox": [ + 107, + 268, + 225, + 281 + ], + "score": 0.29, + "content": "X \\in [ 1 0 \\% , 2 5 \\% , 4 0 \\% , 1 \\dot { 0 } \\dot { 0 } \\% ]", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 268, + 311, + 282 + ], + "score": 1.0, + "content": ". Note that while both", + "type": "text" + }, + { + "bbox": [ + 312, + 269, + 335, + 280 + ], + "score": 0.72, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 268, + 506, + 282 + ], + "score": 1.0, + "content": "and DT introduce hyperparameters, returns", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 280, + 505, + 293 + ], + "spans": [ + { + "bbox": [ + 106, + 280, + 505, + 293 + ], + "score": 1.0, + "content": "are human interpretable and it is relatively natural for humans to specify a desired return compared to", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 291, + 505, + 302 + ], + "spans": [ + { + "bbox": [ + 106, + 291, + 505, + 302 + ], + "score": 1.0, + "content": "choosing an optimal subset for cloning. When data is plentiful – as in the D4RL regime – we find", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 301, + 505, + 314 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 129, + 312 + ], + "score": 0.76, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 301, + 505, + 314 + ], + "score": 1.0, + "content": "can match or beat other offline RL methods. On most environments, Decision Transformer is", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 312, + 506, + 325 + ], + "spans": [ + { + "bbox": [ + 106, + 312, + 289, + 325 + ], + "score": 1.0, + "content": "competitive with the performance of the best", + "type": "text" + }, + { + "bbox": [ + 290, + 313, + 313, + 323 + ], + "score": 0.66, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 312, + 506, + 325 + ], + "score": 1.0, + "content": ", indicating it can hone in on a particular subset", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 325, + 293, + 335 + ], + "spans": [ + { + "bbox": [ + 106, + 325, + 293, + 335 + ], + "score": 1.0, + "content": "after training on the entire dataset distribution.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 9, + "bbox_fs": [ + 105, + 257, + 506, + 335 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 339, + 505, + 417 + ], + "lines": [ + { + "bbox": [ + 106, + 340, + 505, + 352 + ], + "spans": [ + { + "bbox": [ + 106, + 340, + 415, + 352 + ], + "score": 1.0, + "content": "In contrast, when we study low data regimes – such as Atari, where we use", + "type": "text" + }, + { + "bbox": [ + 416, + 340, + 430, + 351 + ], + "score": 0.86, + "content": "1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 431, + 340, + 505, + 352 + ], + "score": 1.0, + "content": "of a replay buffer", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 351, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 170, + 363 + ], + "score": 1.0, + "content": "as the dataset –", + "type": "text" + }, + { + "bbox": [ + 170, + 351, + 196, + 361 + ], + "score": 0.52, + "content": "\\mathbf { \\nabla } \\cdot \\% \\mathbf { B } \\mathbf { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 351, + 505, + 363 + ], + "score": 1.0, + "content": "is weak (shown in Table 4). This suggests that in scenarios with relatively", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 361, + 505, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 354, + 374 + ], + "score": 1.0, + "content": "low amounts of data, Decision Transformer can outperform", + "type": "text" + }, + { + "bbox": [ + 355, + 362, + 379, + 372 + ], + "score": 0.79, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 361, + 505, + 374 + ], + "score": 1.0, + "content": "by using all trajectories in the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 371, + 506, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 506, + 387 + ], + "score": 1.0, + "content": "dataset to improve generalization, even if those trajectories are dissimilar from the return conditioning", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 383, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 505, + 397 + ], + "score": 1.0, + "content": "target. Our results indicate that Decision Transformer can be more effective than simply performing", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 395, + 505, + 406 + ], + "spans": [ + { + "bbox": [ + 106, + 395, + 505, + 406 + ], + "score": 1.0, + "content": "imitation learning on a subset of the dataset. On the tasks we considered, Decision Transformer either", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 405, + 504, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 237, + 418 + ], + "score": 1.0, + "content": "outperforms or is competitive to", + "type": "text" + }, + { + "bbox": [ + 237, + 406, + 260, + 416 + ], + "score": 0.74, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 405, + 504, + 418 + ], + "score": 1.0, + "content": ", without the confound of having to select the optimal subset.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 16, + "bbox_fs": [ + 105, + 340, + 506, + 418 + ] + }, + { + "type": "table", + "bbox": [ + 133, + 427, + 475, + 491 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 133, + 427, + 475, + 491 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 133, + 427, + 475, + 491 + ], + "spans": [ + { + "bbox": [ + 133, + 427, + 475, + 491 + ], + "score": 0.979, + "html": "
GameDT (Ours)10%BC25%BC40%BC100%BC
Breakout267.5 ± 97.528.5±8.273.5 ± 6.4108.2 ± 67.5138.9 ± 61.7
Qbert15.1 ± 11.46.6 ± 1.716.0 ± 13.811.8± 5.817.3 ± 14.7
Pong106.1 ±8.12.5± 0.213.3 ± 2.772.7 ± 13.385.2 ± 20.0
Seaquest2.4 ± 0.71.1 ± 0.21.1 ± 0.21.6 ± 0.42.1 ± 0.3
", + "type": "table", + "image_path": "f7b3e0dda54d8e04dec597f56f451d1866f4fd896d6e53dc669b8062bb2381af.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 133, + 427, + 475, + 448.3333333333333 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 133, + 448.3333333333333, + 475, + 469.66666666666663 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 133, + 469.66666666666663, + 475, + 490.99999999999994 + ], + "spans": [], + "index": 22 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 106, + 495, + 505, + 518 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 494, + 505, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 140, + 508 + ], + "score": 1.0, + "content": "Table 4:", + "type": "text" + }, + { + "bbox": [ + 140, + 496, + 163, + 506 + ], + "score": 0.32, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 494, + 505, + 508 + ], + "score": 1.0, + "content": "scores for Atari. We report the mean and variance across 3 seeds. Decision Transformer", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 506, + 325, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 238, + 519 + ], + "score": 1.0, + "content": "(DT) outperforms all versions of", + "type": "text" + }, + { + "bbox": [ + 239, + 507, + 262, + 517 + ], + "score": 0.5, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 506, + 325, + 519 + ], + "score": 1.0, + "content": "in most games.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5 + } + ], + "index": 22.25 + }, + { + "type": "title", + "bbox": [ + 108, + 536, + 433, + 549 + ], + "lines": [ + { + "bbox": [ + 106, + 537, + 434, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 434, + 550 + ], + "score": 1.0, + "content": "5.2 How well does Decision Transformer model the distribution of returns?", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 557, + 505, + 656 + ], + "lines": [ + { + "bbox": [ + 106, + 558, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 558, + 505, + 569 + ], + "score": 1.0, + "content": "We evaluate the ability of Decision Transformer to understand return-to-go tokens by varying the", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 568, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 506, + 581 + ], + "score": 1.0, + "content": "desired target return over a wide range – evaluating the multi-task distribution modeling capability of", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 579, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 506, + 592 + ], + "score": 1.0, + "content": "transformers. Figure 4 shows the average sampled return accumulated by the agent over the course of", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 589, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 505, + 603 + ], + "score": 1.0, + "content": "the evaluation episode for varying values of target return. On every task, the desired target returns", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 601, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 506, + 614 + ], + "score": 1.0, + "content": "and the true observed returns are highly correlated. On some tasks like Pong, HalfCheetah and", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 612, + 506, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 506, + 625 + ], + "score": 1.0, + "content": "Walker, Decision Transformer generates trajectories that almost perfectly match the desired returns", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 622, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 106, + 622, + 505, + 636 + ], + "score": 1.0, + "content": "(as indicated by the overlap with the oracle line). Furthermore, on some Atari tasks like Seaquest, we", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "score": 1.0, + "content": "can prompt the Decision Transformer with higher returns than the maximum episode return available", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 645, + 486, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 645, + 486, + 657 + ], + "score": 1.0, + "content": "in the dataset, demonstrating that Decision Transformer is sometimes capable of extrapolation.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 30, + "bbox_fs": [ + 105, + 558, + 506, + 657 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 668, + 447, + 681 + ], + "lines": [ + { + "bbox": [ + 105, + 668, + 449, + 682 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 449, + 682 + ], + "score": 1.0, + "content": "5.3 Does Decision Transformer perform effective long-term credit assignment?", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 108, + 689, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 689, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 505, + 701 + ], + "score": 1.0, + "content": "To evaluate long-term credit assignment capabilities of our model, we consider a variant of the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 505, + 712 + ], + "score": 1.0, + "content": "Key-to-Door environment proposed in Mesnard et al. [15]. This is a grid-based environment with a", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "sequence of three phases: (1) in the first phase, the agent is placed in a room with a key; (2) then, the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 246, + 506, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 506, + 259 + ], + "score": 1.0, + "content": "agent is placed in an empty room; (3) and finally, the agent is placed in a room with a door. The agent", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 257, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 257, + 505, + 271 + ], + "score": 1.0, + "content": "receives a binary reward when reaching the door in the third phase, but only if it picked up the key", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 269, + 505, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 269, + 505, + 281 + ], + "score": 1.0, + "content": "in the first phase. This problem is difficult for credit assignment because credit must be propagated", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 280, + 457, + 291 + ], + "spans": [ + { + "bbox": [ + 105, + 280, + 457, + 291 + ], + "score": 1.0, + "content": "from the beginning to the end of the episode, skipping over actions taken in the middle.", + "type": "text", + "cross_page": true + } + ], + "index": 8 + } + ], + "index": 37, + "bbox_fs": [ + 106, + 689, + 505, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 69, + 506, + 191 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 69, + 506, + 191 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 69, + 506, + 191 + ], + "spans": [ + { + "bbox": [ + 106, + 69, + 506, + 191 + ], + "score": 0.974, + "type": "image", + "image_path": "c1156eaeb2971806e2c5eb8d09680aa47f4f5cf207c581cf8c22a3d777eebeb5.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 69, + 506, + 109.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 109.66666666666666, + 506, + 150.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 150.33333333333331, + 506, + 190.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 200, + 504, + 223 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 200, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 106, + 200, + 505, + 213 + ], + "score": 1.0, + "content": "Figure 4: Sampled (evaluation) returns accumulated by Decision Transformer when conditioned on", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 211, + 469, + 224 + ], + "spans": [ + { + "bbox": [ + 106, + 211, + 469, + 224 + ], + "score": 1.0, + "content": "the specified target (desired) returns. Top: Atari. Bottom: D4RL medium-replay datasets.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 107, + 246, + 505, + 290 + ], + "lines": [ + { + "bbox": [ + 105, + 246, + 506, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 506, + 259 + ], + "score": 1.0, + "content": "agent is placed in an empty room; (3) and finally, the agent is placed in a room with a door. The agent", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 257, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 257, + 505, + 271 + ], + "score": 1.0, + "content": "receives a binary reward when reaching the door in the third phase, but only if it picked up the key", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 269, + 505, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 269, + 505, + 281 + ], + "score": 1.0, + "content": "in the first phase. This problem is difficult for credit assignment because credit must be propagated", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 280, + 457, + 291 + ], + "spans": [ + { + "bbox": [ + 105, + 280, + 457, + 291 + ], + "score": 1.0, + "content": "from the beginning to the end of the episode, skipping over actions taken in the middle.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 107, + 295, + 504, + 372 + ], + "lines": [ + { + "bbox": [ + 105, + 295, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 506, + 310 + ], + "score": 1.0, + "content": "We train on datasets of trajectories generated by applying random actions and report success rates", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 307, + 506, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 506, + 320 + ], + "score": 1.0, + "content": "in Table 5. Furthermore, for the Key-to-Door environment we use the entire episode length as the", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 318, + 506, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 506, + 330 + ], + "score": 1.0, + "content": "context, rather than having a fixed content window as in the other environments. Methods that use", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 329, + 505, + 341 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 372, + 341 + ], + "score": 1.0, + "content": "highsight return information: our Decision Transformer model and", + "type": "text" + }, + { + "bbox": [ + 373, + 329, + 396, + 339 + ], + "score": 0.81, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 396, + 329, + 505, + 341 + ], + "score": 1.0, + "content": "(trained only on successful", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 339, + 506, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 506, + 353 + ], + "score": 1.0, + "content": "episodes) are able to learn effective policies – producing near-optimal paths, despite only training", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 351, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 375, + 363 + ], + "score": 1.0, + "content": "on random walks. TD learning (CQL) cannot effectively propagate", + "type": "text" + }, + { + "bbox": [ + 375, + 351, + 384, + 362 + ], + "score": 0.3, + "content": "\\mathrm { Q }", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 351, + 505, + 363 + ], + "score": 1.0, + "content": "-values over the long horizons", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 362, + 254, + 373 + ], + "spans": [ + { + "bbox": [ + 106, + 362, + 254, + 373 + ], + "score": 1.0, + "content": "involved and gets poor performance.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 12 + }, + { + "type": "table", + "bbox": [ + 149, + 387, + 459, + 430 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 149, + 387, + 459, + 430 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 149, + 387, + 459, + 430 + ], + "spans": [ + { + "bbox": [ + 149, + 387, + 459, + 430 + ], + "score": 0.973, + "html": "
DatasetDT (Ours)CQLBC%BCRandom
1K Random Trajectories71.8%13.1%1.4%69.9%3.1%
10K Random Trajectories94.6%13.3%1.6%95.1%3.1%
", + "type": "table", + "image_path": "b098074bab96a0d61716bb08dc399340315f12820eb4c04ac2b973cf59169be0.jpg" + } + ] + } + ], + "index": 17, + "virtual_lines": [ + { + "bbox": [ + 149, + 387, + 459, + 401.3333333333333 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 149, + 401.3333333333333, + 459, + 415.66666666666663 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 149, + 415.66666666666663, + 459, + 429.99999999999994 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 105, + 435, + 507, + 458 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 434, + 507, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 507, + 448 + ], + "score": 1.0, + "content": "Table 5: Success rate for Key-to-Door environment. Methods using hindsight (Decision Transformer,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 446, + 485, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 447, + 129, + 457 + ], + "score": 0.47, + "content": "\\% \\mathbf { B } \\mathbf { C } _ { \\epsilon }", + "type": "inline_equation" + }, + { + "bbox": [ + 130, + 446, + 485, + 459 + ], + "score": 1.0, + "content": ") can learn successful policies, while TD learning struggles to perform credit assignment.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5 + } + ], + "index": 18.25 + }, + { + "type": "title", + "bbox": [ + 107, + 486, + 399, + 497 + ], + "lines": [ + { + "bbox": [ + 105, + 484, + 401, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 401, + 500 + ], + "score": 1.0, + "content": "5.4 Can transformers be accurate critics in sparse reward settings?", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 507, + 506, + 584 + ], + "lines": [ + { + "bbox": [ + 106, + 507, + 506, + 520 + ], + "spans": [ + { + "bbox": [ + 106, + 507, + 506, + 520 + ], + "score": 1.0, + "content": "In previous sections, we established that decision transformer can produce effective policies (actors).", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 517, + 506, + 531 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 506, + 531 + ], + "score": 1.0, + "content": "We now evaluate whether transformer models can also be effective critics. We modify Decision", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 529, + 506, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 506, + 542 + ], + "score": 1.0, + "content": "Transformer to output return tokens in addition to action tokens on the Key-to-Door environment.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 540, + 505, + 553 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 505, + 553 + ], + "score": 1.0, + "content": "We find that the transformer continuously updates reward probability based on events during the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 551, + 506, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 506, + 564 + ], + "score": 1.0, + "content": "episode, shown in Figure 5 (Left). Furthermore, we find the transformer attends to critical events in", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 563, + 505, + 575 + ], + "spans": [ + { + "bbox": [ + 106, + 563, + 505, + 575 + ], + "score": 1.0, + "content": "the episode (picking up the key or reaching the door), shown in Figure 5 (Right), indicating formation", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 573, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 106, + 573, + 506, + 585 + ], + "score": 1.0, + "content": "of state-reward associations as discussed in Raposo et al. [26] and enabling accurate value prediction.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 25 + }, + { + "type": "title", + "bbox": [ + 106, + 601, + 416, + 613 + ], + "lines": [ + { + "bbox": [ + 105, + 600, + 418, + 615 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 418, + 615 + ], + "score": 1.0, + "content": "5.5 Does Decision Transformer perform well in sparse reward settings?", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 623, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 623, + 506, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 623, + 506, + 636 + ], + "score": 1.0, + "content": "A known weakness of TD learning algorithms is that they require densely populated rewards in order", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 633, + 505, + 647 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 505, + 647 + ], + "score": 1.0, + "content": "to perform well, which can be unrealistic and/or expensive. In contrast, Decision Transformer can", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 646, + 506, + 658 + ], + "spans": [ + { + "bbox": [ + 106, + 646, + 506, + 658 + ], + "score": 1.0, + "content": "improve robustness in these settings since it makes minimal assumptions on the density of the reward.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 655, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 506, + 669 + ], + "score": 1.0, + "content": "To evaluate this, we consider a delayed return version of the D4RL benchmarks where the agent", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 667, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 505, + 680 + ], + "score": 1.0, + "content": "does not receive any rewards along the trajectory, and instead receives the cumulative reward of the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 677, + 506, + 692 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 692 + ], + "score": 1.0, + "content": "trajectory in the final timestep. Our results for delayed returns are shown in Table 6. Delayed returns", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 689, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 505, + 701 + ], + "score": 1.0, + "content": "minimally affect Decision Transformer; and due to the nature of the training process, while imitation", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 481, + 712 + ], + "score": 1.0, + "content": "learning methods are reward agnostic. While TD learning collapses, Decision Transformer and", + "type": "text" + }, + { + "bbox": [ + 482, + 700, + 505, + 711 + ], + "score": 0.65, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 711, + 488, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 488, + 723 + ], + "score": 1.0, + "content": "still perform well, indicating that Decision Transformer can be more robust to delayed rewards.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 34 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 742, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 12, + "width": 9 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 69, + 506, + 191 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 69, + 506, + 191 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 69, + 506, + 191 + ], + "spans": [ + { + "bbox": [ + 106, + 69, + 506, + 191 + ], + "score": 0.974, + "type": "image", + "image_path": "c1156eaeb2971806e2c5eb8d09680aa47f4f5cf207c581cf8c22a3d777eebeb5.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 69, + 506, + 109.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 109.66666666666666, + 506, + 150.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 150.33333333333331, + 506, + 190.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 200, + 504, + 223 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 200, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 106, + 200, + 505, + 213 + ], + "score": 1.0, + "content": "Figure 4: Sampled (evaluation) returns accumulated by Decision Transformer when conditioned on", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 211, + 469, + 224 + ], + "spans": [ + { + "bbox": [ + 106, + 211, + 469, + 224 + ], + "score": 1.0, + "content": "the specified target (desired) returns. Top: Atari. Bottom: D4RL medium-replay datasets.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 107, + 246, + 505, + 290 + ], + "lines": [], + "index": 6.5, + "bbox_fs": [ + 105, + 246, + 506, + 291 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 295, + 504, + 372 + ], + "lines": [ + { + "bbox": [ + 105, + 295, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 506, + 310 + ], + "score": 1.0, + "content": "We train on datasets of trajectories generated by applying random actions and report success rates", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 307, + 506, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 506, + 320 + ], + "score": 1.0, + "content": "in Table 5. Furthermore, for the Key-to-Door environment we use the entire episode length as the", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 318, + 506, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 506, + 330 + ], + "score": 1.0, + "content": "context, rather than having a fixed content window as in the other environments. Methods that use", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 329, + 505, + 341 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 372, + 341 + ], + "score": 1.0, + "content": "highsight return information: our Decision Transformer model and", + "type": "text" + }, + { + "bbox": [ + 373, + 329, + 396, + 339 + ], + "score": 0.81, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + }, + { + "bbox": [ + 396, + 329, + 505, + 341 + ], + "score": 1.0, + "content": "(trained only on successful", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 339, + 506, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 506, + 353 + ], + "score": 1.0, + "content": "episodes) are able to learn effective policies – producing near-optimal paths, despite only training", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 351, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 375, + 363 + ], + "score": 1.0, + "content": "on random walks. TD learning (CQL) cannot effectively propagate", + "type": "text" + }, + { + "bbox": [ + 375, + 351, + 384, + 362 + ], + "score": 0.3, + "content": "\\mathrm { Q }", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 351, + 505, + 363 + ], + "score": 1.0, + "content": "-values over the long horizons", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 362, + 254, + 373 + ], + "spans": [ + { + "bbox": [ + 106, + 362, + 254, + 373 + ], + "score": 1.0, + "content": "involved and gets poor performance.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 295, + 506, + 373 + ] + }, + { + "type": "table", + "bbox": [ + 149, + 387, + 459, + 430 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 149, + 387, + 459, + 430 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 149, + 387, + 459, + 430 + ], + "spans": [ + { + "bbox": [ + 149, + 387, + 459, + 430 + ], + "score": 0.973, + "html": "
DatasetDT (Ours)CQLBC%BCRandom
1K Random Trajectories71.8%13.1%1.4%69.9%3.1%
10K Random Trajectories94.6%13.3%1.6%95.1%3.1%
", + "type": "table", + "image_path": "b098074bab96a0d61716bb08dc399340315f12820eb4c04ac2b973cf59169be0.jpg" + } + ] + } + ], + "index": 17, + "virtual_lines": [ + { + "bbox": [ + 149, + 387, + 459, + 401.3333333333333 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 149, + 401.3333333333333, + 459, + 415.66666666666663 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 149, + 415.66666666666663, + 459, + 429.99999999999994 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 105, + 435, + 507, + 458 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 434, + 507, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 507, + 448 + ], + "score": 1.0, + "content": "Table 5: Success rate for Key-to-Door environment. Methods using hindsight (Decision Transformer,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 446, + 485, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 447, + 129, + 457 + ], + "score": 0.47, + "content": "\\% \\mathbf { B } \\mathbf { C } _ { \\epsilon }", + "type": "inline_equation" + }, + { + "bbox": [ + 130, + 446, + 485, + 459 + ], + "score": 1.0, + "content": ") can learn successful policies, while TD learning struggles to perform credit assignment.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5 + } + ], + "index": 18.25 + }, + { + "type": "title", + "bbox": [ + 107, + 486, + 399, + 497 + ], + "lines": [ + { + "bbox": [ + 105, + 484, + 401, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 401, + 500 + ], + "score": 1.0, + "content": "5.4 Can transformers be accurate critics in sparse reward settings?", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 507, + 506, + 584 + ], + "lines": [ + { + "bbox": [ + 106, + 507, + 506, + 520 + ], + "spans": [ + { + "bbox": [ + 106, + 507, + 506, + 520 + ], + "score": 1.0, + "content": "In previous sections, we established that decision transformer can produce effective policies (actors).", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 517, + 506, + 531 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 506, + 531 + ], + "score": 1.0, + "content": "We now evaluate whether transformer models can also be effective critics. We modify Decision", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 529, + 506, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 506, + 542 + ], + "score": 1.0, + "content": "Transformer to output return tokens in addition to action tokens on the Key-to-Door environment.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 540, + 505, + 553 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 505, + 553 + ], + "score": 1.0, + "content": "We find that the transformer continuously updates reward probability based on events during the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 551, + 506, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 506, + 564 + ], + "score": 1.0, + "content": "episode, shown in Figure 5 (Left). Furthermore, we find the transformer attends to critical events in", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 563, + 505, + 575 + ], + "spans": [ + { + "bbox": [ + 106, + 563, + 505, + 575 + ], + "score": 1.0, + "content": "the episode (picking up the key or reaching the door), shown in Figure 5 (Right), indicating formation", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 573, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 106, + 573, + 506, + 585 + ], + "score": 1.0, + "content": "of state-reward associations as discussed in Raposo et al. [26] and enabling accurate value prediction.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 507, + 506, + 585 + ] + }, + { + "type": "title", + "bbox": [ + 106, + 601, + 416, + 613 + ], + "lines": [ + { + "bbox": [ + 105, + 600, + 418, + 615 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 418, + 615 + ], + "score": 1.0, + "content": "5.5 Does Decision Transformer perform well in sparse reward settings?", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 623, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 623, + 506, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 623, + 506, + 636 + ], + "score": 1.0, + "content": "A known weakness of TD learning algorithms is that they require densely populated rewards in order", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 633, + 505, + 647 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 505, + 647 + ], + "score": 1.0, + "content": "to perform well, which can be unrealistic and/or expensive. In contrast, Decision Transformer can", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 646, + 506, + 658 + ], + "spans": [ + { + "bbox": [ + 106, + 646, + 506, + 658 + ], + "score": 1.0, + "content": "improve robustness in these settings since it makes minimal assumptions on the density of the reward.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 655, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 506, + 669 + ], + "score": 1.0, + "content": "To evaluate this, we consider a delayed return version of the D4RL benchmarks where the agent", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 667, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 505, + 680 + ], + "score": 1.0, + "content": "does not receive any rewards along the trajectory, and instead receives the cumulative reward of the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 677, + 506, + 692 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 692 + ], + "score": 1.0, + "content": "trajectory in the final timestep. Our results for delayed returns are shown in Table 6. Delayed returns", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 689, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 505, + 701 + ], + "score": 1.0, + "content": "minimally affect Decision Transformer; and due to the nature of the training process, while imitation", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 481, + 712 + ], + "score": 1.0, + "content": "learning methods are reward agnostic. While TD learning collapses, Decision Transformer and", + "type": "text" + }, + { + "bbox": [ + 482, + 700, + 505, + 711 + ], + "score": 0.65, + "content": "\\% \\mathrm { B C }", + "type": "inline_equation" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 711, + 488, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 488, + 723 + ], + "score": 1.0, + "content": "still perform well, indicating that Decision Transformer can be more robust to delayed rewards.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 34, + "bbox_fs": [ + 105, + 623, + 506, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 145, + 80, + 451, + 187 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 145, + 80, + 451, + 187 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 145, + 80, + 451, + 187 + ], + "spans": [ + { + "bbox": [ + 145, + 80, + 451, + 187 + ], + "score": 0.953, + "type": "image", + "image_path": "2cf047d6f6123e6feee315d97b0f7169c03581ba80dfd8637dd3453482f91ce9.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 145, + 80, + 451, + 115.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 145, + 115.66666666666666, + 451, + 151.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 145, + 151.33333333333331, + 451, + 186.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 195, + 505, + 240 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 195, + 505, + 209 + ], + "spans": [ + { + "bbox": [ + 106, + 195, + 505, + 209 + ], + "score": 1.0, + "content": "Figure 5: Left: Averages of running return probabilities predicted by the transformer model for three", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 207, + 506, + 219 + ], + "spans": [ + { + "bbox": [ + 105, + 207, + 506, + 219 + ], + "score": 1.0, + "content": "types of episode outcomes. Right: Transformer attention weights from all timesteps superimposed", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 217, + 506, + 231 + ], + "spans": [ + { + "bbox": [ + 105, + 217, + 506, + 231 + ], + "score": 1.0, + "content": "for a particular successful episode. The model attends to steps near pivotal events in the episode, such", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 229, + 285, + 241 + ], + "spans": [ + { + "bbox": [ + 105, + 229, + 285, + 241 + ], + "score": 1.0, + "content": "as picking up the key and reaching the door.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "table", + "bbox": [ + 116, + 252, + 492, + 316 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 116, + 252, + 492, + 316 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 116, + 252, + 492, + 316 + ], + "spans": [ + { + "bbox": [ + 116, + 252, + 492, + 316 + ], + "score": 0.976, + "html": "
EnvironmentDelayed (Sparse)AgnosticOriginal (Dense)
DatasetDT (Ours)CQLBC%BCDT (Ours)CQL
Medium-ExpertHopper107.3 ± 3.59.059.9102.6107.6111.0
MediumHopper60.7± 4.55.263.965.967.658.0
Medium-ReplayHopper78.5 ± 3.72.027.670.682.748.6
", + "type": "table", + "image_path": "30abdf3c2bb5d25d47c7adf3a2f6138477792c0148cf52e9f901c6b39aaf9f6e.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 116, + 252, + 492, + 273.3333333333333 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 116, + 273.3333333333333, + 492, + 294.66666666666663 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 116, + 294.66666666666663, + 492, + 315.99999999999994 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 106, + 321, + 505, + 344 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 321, + 505, + 334 + ], + "spans": [ + { + "bbox": [ + 106, + 321, + 505, + 334 + ], + "score": 1.0, + "content": "Table 6: Results for D4RL datasets with delayed (sparse) reward. Decision Transformer (DT) and", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 331, + 475, + 344 + ], + "spans": [ + { + "bbox": [ + 106, + 331, + 475, + 344 + ], + "score": 1.0, + "content": "imitation learning are minimally affected by the removal of dense rewards, while CQL fails.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5 + } + ], + "index": 9.25 + }, + { + "type": "title", + "bbox": [ + 107, + 366, + 227, + 378 + ], + "lines": [ + { + "bbox": [ + 105, + 365, + 228, + 379 + ], + "spans": [ + { + "bbox": [ + 105, + 365, + 228, + 379 + ], + "score": 1.0, + "content": "5.6 Additional Discussions", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 387, + 320, + 399 + ], + "lines": [ + { + "bbox": [ + 105, + 386, + 322, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 322, + 401 + ], + "score": 1.0, + "content": "For more discussions see the supplementary material.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "title", + "bbox": [ + 107, + 417, + 194, + 430 + ], + "lines": [ + { + "bbox": [ + 105, + 416, + 196, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 196, + 432 + ], + "score": 1.0, + "content": "6 Related work", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 443, + 505, + 553 + ], + "lines": [ + { + "bbox": [ + 106, + 443, + 506, + 456 + ], + "spans": [ + { + "bbox": [ + 106, + 443, + 506, + 456 + ], + "score": 1.0, + "content": "Offline reinforcement learning. To mitigate the impact of distribution shift in offline RL, prior", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 453, + 506, + 468 + ], + "spans": [ + { + "bbox": [ + 106, + 453, + 506, + 468 + ], + "score": 1.0, + "content": "algorithms either (a) constrain the policy action space [27, 28, 29] or (b) incorporate value pes-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 465, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 106, + 465, + 505, + 477 + ], + "score": 1.0, + "content": "simism [27, 17], or (c) incorporate pessimism into learned dynamics models [30, 31]. Since we do", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 476, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 106, + 476, + 506, + 488 + ], + "score": 1.0, + "content": "not use Decision Transformers to explicitly learn the dynamics model, we primarily compare against", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 487, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 505, + 500 + ], + "score": 1.0, + "content": "model-free algorithms; adding a dynamics model tends to improve the performance of model-free", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 498, + 506, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 506, + 510 + ], + "score": 1.0, + "content": "algorithms. Another line of work explores learning wide behavior distribution from an offline dataset", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 507, + 506, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 506, + 522 + ], + "score": 1.0, + "content": "by learning a task-agnostic set of skills, either with likelihood-based approaches [32, 33, 34, 35] or by", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 519, + 506, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 519, + 506, + 533 + ], + "score": 1.0, + "content": "maximizing mutual information [36, 37, 38]. Our work is similar to the likelihood-based approaches,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 530, + 506, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 506, + 543 + ], + "score": 1.0, + "content": "which do not use iterative Bellman updates – although we use a simpler sequence modeling objective", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 541, + 461, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 461, + 555 + ], + "score": 1.0, + "content": "instead of a variational method, and use rewards for conditional generation of behaviors.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 106, + 559, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 558, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 106, + 558, + 506, + 570 + ], + "score": 1.0, + "content": "Supervised learning in reinforcement learning settings. Some prior methods for reinforcement", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 569, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 505, + 581 + ], + "score": 1.0, + "content": "learning bear more resemblance to static supervised learning, such as Q-learning [39, 40], which still", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 580, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 106, + 580, + 505, + 591 + ], + "score": 1.0, + "content": "uses iterative backups, or likelihood-based methods such as behavior cloning, which do not (discussed", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 591, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 591, + 506, + 603 + ], + "score": 1.0, + "content": "in previous section). Recent work [8, 9, 10] studies “upside-down” reinforcement learning (UDRL),", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 601, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 601, + 506, + 614 + ], + "score": 1.0, + "content": "which are similar to our method in seeking to model behaviors with a supervised loss conditioned", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 612, + 506, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 506, + 626 + ], + "score": 1.0, + "content": "on the target return. A key difference in our work is the shift of motivation to sequence modeling", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 624, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 505, + 635 + ], + "score": 1.0, + "content": "rather than supervised learning: while the practical methods differ primarily in the context length and", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 635, + 506, + 647 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 506, + 647 + ], + "score": 1.0, + "content": "architecture, sequence modeling enables behavior modeling even without access to the reward, in a", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 644, + 506, + 659 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 506, + 659 + ], + "score": 1.0, + "content": "similar style to language [12] or images [41], and is known to scale well [2]. The method proposed by", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 655, + 506, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 313, + 670 + ], + "score": 1.0, + "content": "Kumar et al. [9] is most similar to our method with", + "type": "text" + }, + { + "bbox": [ + 313, + 657, + 342, + 666 + ], + "score": 0.87, + "content": "K = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 655, + 506, + 670 + ], + "score": 1.0, + "content": ", which we find sequence modeling/long", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 667, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 505, + 680 + ], + "score": 1.0, + "content": "contexts to outperform (see supplementary material). Ghosh et al. [42] extends prior UDRL methods", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 678, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 505, + 690 + ], + "score": 1.0, + "content": "to use state goal conditioning, rather than rewards, and Paster et al. [43] further use an LSTM with", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 689, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 506, + 701 + ], + "score": 1.0, + "content": "state goal conditioning for goal-conditoned online RL settings. Concurrent to our work, Janner et al.", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 505, + 712 + ], + "score": 1.0, + "content": "[44] propose Trajectory Transformer, which is similar to Decision Transformer but additionally uses", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 711, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 506, + 723 + ], + "score": 1.0, + "content": "state and return prediction, as well as discretization, which incorporates model-based components.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 32 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 145, + 80, + 451, + 187 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 145, + 80, + 451, + 187 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 145, + 80, + 451, + 187 + ], + "spans": [ + { + "bbox": [ + 145, + 80, + 451, + 187 + ], + "score": 0.953, + "type": "image", + "image_path": "2cf047d6f6123e6feee315d97b0f7169c03581ba80dfd8637dd3453482f91ce9.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 145, + 80, + 451, + 115.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 145, + 115.66666666666666, + 451, + 151.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 145, + 151.33333333333331, + 451, + 186.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 195, + 505, + 240 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 195, + 505, + 209 + ], + "spans": [ + { + "bbox": [ + 106, + 195, + 505, + 209 + ], + "score": 1.0, + "content": "Figure 5: Left: Averages of running return probabilities predicted by the transformer model for three", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 207, + 506, + 219 + ], + "spans": [ + { + "bbox": [ + 105, + 207, + 506, + 219 + ], + "score": 1.0, + "content": "types of episode outcomes. Right: Transformer attention weights from all timesteps superimposed", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 217, + 506, + 231 + ], + "spans": [ + { + "bbox": [ + 105, + 217, + 506, + 231 + ], + "score": 1.0, + "content": "for a particular successful episode. The model attends to steps near pivotal events in the episode, such", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 229, + 285, + 241 + ], + "spans": [ + { + "bbox": [ + 105, + 229, + 285, + 241 + ], + "score": 1.0, + "content": "as picking up the key and reaching the door.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "table", + "bbox": [ + 116, + 252, + 492, + 316 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 116, + 252, + 492, + 316 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 116, + 252, + 492, + 316 + ], + "spans": [ + { + "bbox": [ + 116, + 252, + 492, + 316 + ], + "score": 0.976, + "html": "
EnvironmentDelayed (Sparse)AgnosticOriginal (Dense)
DatasetDT (Ours)CQLBC%BCDT (Ours)CQL
Medium-ExpertHopper107.3 ± 3.59.059.9102.6107.6111.0
MediumHopper60.7± 4.55.263.965.967.658.0
Medium-ReplayHopper78.5 ± 3.72.027.670.682.748.6
", + "type": "table", + "image_path": "30abdf3c2bb5d25d47c7adf3a2f6138477792c0148cf52e9f901c6b39aaf9f6e.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 116, + 252, + 492, + 273.3333333333333 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 116, + 273.3333333333333, + 492, + 294.66666666666663 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 116, + 294.66666666666663, + 492, + 315.99999999999994 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 106, + 321, + 505, + 344 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 321, + 505, + 334 + ], + "spans": [ + { + "bbox": [ + 106, + 321, + 505, + 334 + ], + "score": 1.0, + "content": "Table 6: Results for D4RL datasets with delayed (sparse) reward. Decision Transformer (DT) and", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 331, + 475, + 344 + ], + "spans": [ + { + "bbox": [ + 106, + 331, + 475, + 344 + ], + "score": 1.0, + "content": "imitation learning are minimally affected by the removal of dense rewards, while CQL fails.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5 + } + ], + "index": 9.25 + }, + { + "type": "title", + "bbox": [ + 107, + 366, + 227, + 378 + ], + "lines": [ + { + "bbox": [ + 105, + 365, + 228, + 379 + ], + "spans": [ + { + "bbox": [ + 105, + 365, + 228, + 379 + ], + "score": 1.0, + "content": "5.6 Additional Discussions", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 387, + 320, + 399 + ], + "lines": [ + { + "bbox": [ + 105, + 386, + 322, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 322, + 401 + ], + "score": 1.0, + "content": "For more discussions see the supplementary material.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13, + "bbox_fs": [ + 105, + 386, + 322, + 401 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 417, + 194, + 430 + ], + "lines": [ + { + "bbox": [ + 105, + 416, + 196, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 196, + 432 + ], + "score": 1.0, + "content": "6 Related work", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 443, + 505, + 553 + ], + "lines": [ + { + "bbox": [ + 106, + 443, + 506, + 456 + ], + "spans": [ + { + "bbox": [ + 106, + 443, + 506, + 456 + ], + "score": 1.0, + "content": "Offline reinforcement learning. To mitigate the impact of distribution shift in offline RL, prior", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 453, + 506, + 468 + ], + "spans": [ + { + "bbox": [ + 106, + 453, + 506, + 468 + ], + "score": 1.0, + "content": "algorithms either (a) constrain the policy action space [27, 28, 29] or (b) incorporate value pes-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 465, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 106, + 465, + 505, + 477 + ], + "score": 1.0, + "content": "simism [27, 17], or (c) incorporate pessimism into learned dynamics models [30, 31]. Since we do", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 476, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 106, + 476, + 506, + 488 + ], + "score": 1.0, + "content": "not use Decision Transformers to explicitly learn the dynamics model, we primarily compare against", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 487, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 505, + 500 + ], + "score": 1.0, + "content": "model-free algorithms; adding a dynamics model tends to improve the performance of model-free", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 498, + 506, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 506, + 510 + ], + "score": 1.0, + "content": "algorithms. Another line of work explores learning wide behavior distribution from an offline dataset", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 507, + 506, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 506, + 522 + ], + "score": 1.0, + "content": "by learning a task-agnostic set of skills, either with likelihood-based approaches [32, 33, 34, 35] or by", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 519, + 506, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 519, + 506, + 533 + ], + "score": 1.0, + "content": "maximizing mutual information [36, 37, 38]. Our work is similar to the likelihood-based approaches,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 530, + 506, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 506, + 543 + ], + "score": 1.0, + "content": "which do not use iterative Bellman updates – although we use a simpler sequence modeling objective", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 541, + 461, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 461, + 555 + ], + "score": 1.0, + "content": "instead of a variational method, and use rewards for conditional generation of behaviors.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 443, + 506, + 555 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 559, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 558, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 106, + 558, + 506, + 570 + ], + "score": 1.0, + "content": "Supervised learning in reinforcement learning settings. Some prior methods for reinforcement", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 569, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 505, + 581 + ], + "score": 1.0, + "content": "learning bear more resemblance to static supervised learning, such as Q-learning [39, 40], which still", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 580, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 106, + 580, + 505, + 591 + ], + "score": 1.0, + "content": "uses iterative backups, or likelihood-based methods such as behavior cloning, which do not (discussed", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 591, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 591, + 506, + 603 + ], + "score": 1.0, + "content": "in previous section). Recent work [8, 9, 10] studies “upside-down” reinforcement learning (UDRL),", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 601, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 601, + 506, + 614 + ], + "score": 1.0, + "content": "which are similar to our method in seeking to model behaviors with a supervised loss conditioned", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 612, + 506, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 506, + 626 + ], + "score": 1.0, + "content": "on the target return. A key difference in our work is the shift of motivation to sequence modeling", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 624, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 505, + 635 + ], + "score": 1.0, + "content": "rather than supervised learning: while the practical methods differ primarily in the context length and", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 635, + 506, + 647 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 506, + 647 + ], + "score": 1.0, + "content": "architecture, sequence modeling enables behavior modeling even without access to the reward, in a", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 644, + 506, + 659 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 506, + 659 + ], + "score": 1.0, + "content": "similar style to language [12] or images [41], and is known to scale well [2]. The method proposed by", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 655, + 506, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 313, + 670 + ], + "score": 1.0, + "content": "Kumar et al. [9] is most similar to our method with", + "type": "text" + }, + { + "bbox": [ + 313, + 657, + 342, + 666 + ], + "score": 0.87, + "content": "K = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 655, + 506, + 670 + ], + "score": 1.0, + "content": ", which we find sequence modeling/long", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 667, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 505, + 680 + ], + "score": 1.0, + "content": "contexts to outperform (see supplementary material). Ghosh et al. [42] extends prior UDRL methods", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 678, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 505, + 690 + ], + "score": 1.0, + "content": "to use state goal conditioning, rather than rewards, and Paster et al. [43] further use an LSTM with", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 689, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 506, + 701 + ], + "score": 1.0, + "content": "state goal conditioning for goal-conditoned online RL settings. Concurrent to our work, Janner et al.", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 505, + 712 + ], + "score": 1.0, + "content": "[44] propose Trajectory Transformer, which is similar to Decision Transformer but additionally uses", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 711, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 506, + 723 + ], + "score": 1.0, + "content": "state and return prediction, as well as discretization, which incorporates model-based components.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 32, + "bbox_fs": [ + 105, + 558, + 506, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 73, + 503, + 95 + ], + "lines": [ + { + "bbox": [ + 106, + 72, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 505, + 86 + ], + "score": 1.0, + "content": "We believe that their experiments, in addition to our results, highlight the potential for sequence", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 83, + 388, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 388, + 97 + ], + "score": 1.0, + "content": "modeling to be a generally applicable idea for reinforcement learning.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 107, + 100, + 505, + 177 + ], + "lines": [ + { + "bbox": [ + 105, + 99, + 505, + 114 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 505, + 114 + ], + "score": 1.0, + "content": "Credit assignment. Many works have studied better credit assignment via state-association, learning", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 111, + 505, + 124 + ], + "spans": [ + { + "bbox": [ + 105, + 111, + 505, + 124 + ], + "score": 1.0, + "content": "an architecture which decomposes the reward function such that certain “important” states comprise", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 121, + 506, + 134 + ], + "spans": [ + { + "bbox": [ + 105, + 121, + 506, + 134 + ], + "score": 1.0, + "content": "most of the credit [45, 46, 15]. They use the learned reward function to change the reward of an actor-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 133, + 505, + 145 + ], + "spans": [ + { + "bbox": [ + 106, + 133, + 505, + 145 + ], + "score": 1.0, + "content": "critic algorithm to help propagate signal over long horizons. In particular, similar to our long-term", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 144, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 144, + 505, + 156 + ], + "score": 1.0, + "content": "setting, some works have specifically shown such state-associative architectures can perform better in", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 155, + 506, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 155, + 506, + 167 + ], + "score": 1.0, + "content": "delayed reward settings [47, 7, 48, 26]. In contrast, we allow these properties to naturally emerge in a", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 165, + 459, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 459, + 178 + ], + "score": 1.0, + "content": "transformer architecture, without having to explicitly learn a reward function or a critic.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 107, + 181, + 505, + 259 + ], + "lines": [ + { + "bbox": [ + 106, + 181, + 505, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 181, + 505, + 195 + ], + "score": 1.0, + "content": "Conditional language generation. Various works have studied guided generation for images [49]", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 192, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 206 + ], + "score": 1.0, + "content": "and language [50, 51]. Several works [52, 53, 54, 55, 56, 57] have explored training or fine-tuning", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 204, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 204, + 505, + 216 + ], + "score": 1.0, + "content": "of models for controllable text generation. Class-conditional language models can also be used to", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 215, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 215, + 505, + 227 + ], + "score": 1.0, + "content": "learn disciminators to guide generation [58, 50, 59, 60]. However, these approaches mostly assume", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 225, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 506, + 239 + ], + "score": 1.0, + "content": "constant “classes”, while in reinforcement learning the reward signal is time-varying. Furthermore, it", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 236, + 505, + 249 + ], + "spans": [ + { + "bbox": [ + 105, + 236, + 505, + 249 + ], + "score": 1.0, + "content": "is more natural to prompt the model desired target return and continuously decrease it by the observed", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 246, + 488, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 488, + 261 + ], + "score": 1.0, + "content": "rewards over time, since the transformer model and environment jointly generate the trajectory.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 263, + 505, + 384 + ], + "lines": [ + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "score": 1.0, + "content": "Attention and transformer models. Transformers [1] have been applied successfully to many tasks", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 275, + 505, + 287 + ], + "spans": [ + { + "bbox": [ + 106, + 275, + 505, + 287 + ], + "score": 1.0, + "content": "in natural language processing [61, 12] and computer vision [62, 63]. However, transformers are", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 285, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 505, + 298 + ], + "score": 1.0, + "content": "relatively unstudied in RL, mostly due to differing nature of the problem, such as higher variance", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 296, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 506, + 310 + ], + "score": 1.0, + "content": "in training. Zambaldi et al. [5] showed that augmenting transformers with relational reasoning", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 307, + 506, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 506, + 319 + ], + "score": 1.0, + "content": "improve performance in combinatorial environments and Ritter et al. [64] showed iterative self-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 318, + 506, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 506, + 330 + ], + "score": 1.0, + "content": "attention allowed for RL agents to better utilize episodic memories. Parisotto et al. [4] discussed", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 329, + 505, + 342 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 505, + 342 + ], + "score": 1.0, + "content": "design decisions for more stable training of transformers in the high-variance RL setting. Unlike", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 340, + 506, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 506, + 353 + ], + "score": 1.0, + "content": "our work, these still use actor-critic algorithms for optimization, focusing on novelty in architecture.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 351, + 506, + 364 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 506, + 364 + ], + "score": 1.0, + "content": "Additionally, in imitation learning, some works have studied transformers as a replacement for", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 362, + 505, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 505, + 374 + ], + "score": 1.0, + "content": "LSTMs: Dasari and Gupta [65] study one-shot imitation learning, and Abramson et al. [66] combine", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 373, + 398, + 385 + ], + "spans": [ + { + "bbox": [ + 106, + 373, + 398, + 385 + ], + "score": 1.0, + "content": "language and image modalities for text-conditioned behavior generation.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 21 + }, + { + "type": "title", + "bbox": [ + 107, + 399, + 183, + 412 + ], + "lines": [ + { + "bbox": [ + 104, + 397, + 185, + 416 + ], + "spans": [ + { + "bbox": [ + 104, + 397, + 185, + 416 + ], + "score": 1.0, + "content": "7 Conclusion", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 424, + 505, + 457 + ], + "lines": [ + { + "bbox": [ + 105, + 423, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 505, + 437 + ], + "score": 1.0, + "content": "We proposed Decision Transformer, seeking to unify ideas in language modeling and RL. On standard", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 434, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 505, + 448 + ], + "score": 1.0, + "content": "offline RL benchmarks, we showed DT can match or outperform strong algorithms designed explicitly", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 445, + 470, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 470, + 459 + ], + "score": 1.0, + "content": "for offline RL with minimal modifications from standard language modeling architectures.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 462, + 505, + 506 + ], + "lines": [ + { + "bbox": [ + 105, + 462, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 505, + 475 + ], + "score": 1.0, + "content": "Societal impact. For real-world applications, it is important to understand the types of errors", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 473, + 506, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 506, + 486 + ], + "score": 1.0, + "content": "transformers make in MDP settings and possible negative consequences. It will also be important to", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 483, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 505, + 497 + ], + "score": 1.0, + "content": "consider the datasets we train on, which can potentially add destructive biases, particularly as we", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 495, + 507, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 507, + 508 + ], + "score": 1.0, + "content": "consider studying augmenting RL agents with more data which may come from questionable sources.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 107, + 511, + 505, + 610 + ], + "lines": [ + { + "bbox": [ + 106, + 511, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 505, + 524 + ], + "score": 1.0, + "content": "Limitations. We introduced our paradigm shift and showed its potential in our experiments, but there", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 522, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 505, + 535 + ], + "score": 1.0, + "content": "is significant room for more research in this direction. The current architecture requires considerations", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 533, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 506, + 546 + ], + "score": 1.0, + "content": "of context length and return-to-go hyperparameters, and we show results on standard RL benchmarks;", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 544, + 505, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 505, + 557 + ], + "score": 1.0, + "content": "future work could improve the architecture and demonstrate results in more complex environments", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 556, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 505, + 568 + ], + "score": 1.0, + "content": "and tasks. We used a simple supervised loss that was effective in our experiments, but applications", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 566, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 505, + 579 + ], + "score": 1.0, + "content": "to large-scale datasets could benefit from self-supervised pretraining tasks. In addition, one could", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 577, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 505, + 590 + ], + "score": 1.0, + "content": "consider more sophisticated embeddings for returns, states, and actions. While we do not directly", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 588, + 504, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 504, + 601 + ], + "score": 1.0, + "content": "evaluate scaling and generalization, we utilize a method known to scale generalize well in domains", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 600, + 501, + 611 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 501, + 611 + ], + "score": 1.0, + "content": "such as language and vision, and we are excited about larger RL systems built upon our framework.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 39 + }, + { + "type": "title", + "bbox": [ + 108, + 625, + 225, + 639 + ], + "lines": [ + { + "bbox": [ + 105, + 624, + 226, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 226, + 641 + ], + "score": 1.0, + "content": "8 Acknowledgements", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 44 + }, + { + "type": "text", + "bbox": [ + 107, + 650, + 505, + 716 + ], + "lines": [ + { + "bbox": [ + 105, + 650, + 505, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 650, + 505, + 663 + ], + "score": 1.0, + "content": "This research was supported by Berkeley Deep Drive, Open Philanthropy, and the National Science", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 661, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 106, + 661, + 505, + 673 + ], + "score": 1.0, + "content": "Foundation under NSF:NRI #2024675. Part of this work was completed when Aravind Rajeswaran", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 672, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 672, + 505, + 685 + ], + "score": 1.0, + "content": "was a PhD student at the University of Washington, where he was supported by the J.P. Morgan PhD", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 684, + 505, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 684, + 505, + 695 + ], + "score": 1.0, + "content": "Fellowship in AI (2020-21). We also thank Luke Metz, Daniel Freeman, and anonymous reviewers for", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 694, + 506, + 707 + ], + "spans": [ + { + "bbox": [ + 105, + 694, + 506, + 707 + ], + "score": 1.0, + "content": "valuable feedback and discussions, as well as Justin Fu for assistance in setting up D4RL benchmarks,", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 704, + 422, + 718 + ], + "spans": [ + { + "bbox": [ + 105, + 704, + 422, + 718 + ], + "score": 1.0, + "content": "and Aviral Kumar for assistance with the CQL baselines and hyperparameters.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 47.5 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 301, + 742, + 311, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 14 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 73, + 503, + 95 + ], + "lines": [ + { + "bbox": [ + 106, + 72, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 505, + 86 + ], + "score": 1.0, + "content": "We believe that their experiments, in addition to our results, highlight the potential for sequence", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 83, + 388, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 388, + 97 + ], + "score": 1.0, + "content": "modeling to be a generally applicable idea for reinforcement learning.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 105, + 72, + 505, + 97 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 100, + 505, + 177 + ], + "lines": [ + { + "bbox": [ + 105, + 99, + 505, + 114 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 505, + 114 + ], + "score": 1.0, + "content": "Credit assignment. Many works have studied better credit assignment via state-association, learning", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 111, + 505, + 124 + ], + "spans": [ + { + "bbox": [ + 105, + 111, + 505, + 124 + ], + "score": 1.0, + "content": "an architecture which decomposes the reward function such that certain “important” states comprise", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 121, + 506, + 134 + ], + "spans": [ + { + "bbox": [ + 105, + 121, + 506, + 134 + ], + "score": 1.0, + "content": "most of the credit [45, 46, 15]. They use the learned reward function to change the reward of an actor-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 133, + 505, + 145 + ], + "spans": [ + { + "bbox": [ + 106, + 133, + 505, + 145 + ], + "score": 1.0, + "content": "critic algorithm to help propagate signal over long horizons. In particular, similar to our long-term", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 144, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 144, + 505, + 156 + ], + "score": 1.0, + "content": "setting, some works have specifically shown such state-associative architectures can perform better in", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 155, + 506, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 155, + 506, + 167 + ], + "score": 1.0, + "content": "delayed reward settings [47, 7, 48, 26]. In contrast, we allow these properties to naturally emerge in a", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 165, + 459, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 459, + 178 + ], + "score": 1.0, + "content": "transformer architecture, without having to explicitly learn a reward function or a critic.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5, + "bbox_fs": [ + 105, + 99, + 506, + 178 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 181, + 505, + 259 + ], + "lines": [ + { + "bbox": [ + 106, + 181, + 505, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 181, + 505, + 195 + ], + "score": 1.0, + "content": "Conditional language generation. Various works have studied guided generation for images [49]", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 192, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 206 + ], + "score": 1.0, + "content": "and language [50, 51]. Several works [52, 53, 54, 55, 56, 57] have explored training or fine-tuning", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 204, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 204, + 505, + 216 + ], + "score": 1.0, + "content": "of models for controllable text generation. Class-conditional language models can also be used to", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 215, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 215, + 505, + 227 + ], + "score": 1.0, + "content": "learn disciminators to guide generation [58, 50, 59, 60]. However, these approaches mostly assume", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 225, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 506, + 239 + ], + "score": 1.0, + "content": "constant “classes”, while in reinforcement learning the reward signal is time-varying. Furthermore, it", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 236, + 505, + 249 + ], + "spans": [ + { + "bbox": [ + 105, + 236, + 505, + 249 + ], + "score": 1.0, + "content": "is more natural to prompt the model desired target return and continuously decrease it by the observed", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 246, + 488, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 488, + 261 + ], + "score": 1.0, + "content": "rewards over time, since the transformer model and environment jointly generate the trajectory.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 181, + 506, + 261 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 263, + 505, + 384 + ], + "lines": [ + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "score": 1.0, + "content": "Attention and transformer models. Transformers [1] have been applied successfully to many tasks", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 275, + 505, + 287 + ], + "spans": [ + { + "bbox": [ + 106, + 275, + 505, + 287 + ], + "score": 1.0, + "content": "in natural language processing [61, 12] and computer vision [62, 63]. However, transformers are", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 285, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 505, + 298 + ], + "score": 1.0, + "content": "relatively unstudied in RL, mostly due to differing nature of the problem, such as higher variance", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 296, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 506, + 310 + ], + "score": 1.0, + "content": "in training. Zambaldi et al. [5] showed that augmenting transformers with relational reasoning", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 307, + 506, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 506, + 319 + ], + "score": 1.0, + "content": "improve performance in combinatorial environments and Ritter et al. [64] showed iterative self-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 318, + 506, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 506, + 330 + ], + "score": 1.0, + "content": "attention allowed for RL agents to better utilize episodic memories. Parisotto et al. [4] discussed", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 329, + 505, + 342 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 505, + 342 + ], + "score": 1.0, + "content": "design decisions for more stable training of transformers in the high-variance RL setting. Unlike", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 340, + 506, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 506, + 353 + ], + "score": 1.0, + "content": "our work, these still use actor-critic algorithms for optimization, focusing on novelty in architecture.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 351, + 506, + 364 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 506, + 364 + ], + "score": 1.0, + "content": "Additionally, in imitation learning, some works have studied transformers as a replacement for", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 362, + 505, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 505, + 374 + ], + "score": 1.0, + "content": "LSTMs: Dasari and Gupta [65] study one-shot imitation learning, and Abramson et al. [66] combine", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 373, + 398, + 385 + ], + "spans": [ + { + "bbox": [ + 106, + 373, + 398, + 385 + ], + "score": 1.0, + "content": "language and image modalities for text-conditioned behavior generation.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 263, + 506, + 385 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 399, + 183, + 412 + ], + "lines": [ + { + "bbox": [ + 104, + 397, + 185, + 416 + ], + "spans": [ + { + "bbox": [ + 104, + 397, + 185, + 416 + ], + "score": 1.0, + "content": "7 Conclusion", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 424, + 505, + 457 + ], + "lines": [ + { + "bbox": [ + 105, + 423, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 505, + 437 + ], + "score": 1.0, + "content": "We proposed Decision Transformer, seeking to unify ideas in language modeling and RL. On standard", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 434, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 505, + 448 + ], + "score": 1.0, + "content": "offline RL benchmarks, we showed DT can match or outperform strong algorithms designed explicitly", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 445, + 470, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 470, + 459 + ], + "score": 1.0, + "content": "for offline RL with minimal modifications from standard language modeling architectures.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29, + "bbox_fs": [ + 105, + 423, + 505, + 459 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 462, + 505, + 506 + ], + "lines": [ + { + "bbox": [ + 105, + 462, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 505, + 475 + ], + "score": 1.0, + "content": "Societal impact. For real-world applications, it is important to understand the types of errors", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 473, + 506, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 506, + 486 + ], + "score": 1.0, + "content": "transformers make in MDP settings and possible negative consequences. It will also be important to", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 483, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 505, + 497 + ], + "score": 1.0, + "content": "consider the datasets we train on, which can potentially add destructive biases, particularly as we", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 495, + 507, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 507, + 508 + ], + "score": 1.0, + "content": "consider studying augmenting RL agents with more data which may come from questionable sources.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 462, + 507, + 508 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 511, + 505, + 610 + ], + "lines": [ + { + "bbox": [ + 106, + 511, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 505, + 524 + ], + "score": 1.0, + "content": "Limitations. We introduced our paradigm shift and showed its potential in our experiments, but there", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 522, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 505, + 535 + ], + "score": 1.0, + "content": "is significant room for more research in this direction. The current architecture requires considerations", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 533, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 506, + 546 + ], + "score": 1.0, + "content": "of context length and return-to-go hyperparameters, and we show results on standard RL benchmarks;", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 544, + 505, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 505, + 557 + ], + "score": 1.0, + "content": "future work could improve the architecture and demonstrate results in more complex environments", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 556, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 505, + 568 + ], + "score": 1.0, + "content": "and tasks. We used a simple supervised loss that was effective in our experiments, but applications", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 566, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 505, + 579 + ], + "score": 1.0, + "content": "to large-scale datasets could benefit from self-supervised pretraining tasks. In addition, one could", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 577, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 505, + 590 + ], + "score": 1.0, + "content": "consider more sophisticated embeddings for returns, states, and actions. While we do not directly", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 588, + 504, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 504, + 601 + ], + "score": 1.0, + "content": "evaluate scaling and generalization, we utilize a method known to scale generalize well in domains", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 600, + 501, + 611 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 501, + 611 + ], + "score": 1.0, + "content": "such as language and vision, and we are excited about larger RL systems built upon our framework.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 39, + "bbox_fs": [ + 105, + 511, + 506, + 611 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 625, + 225, + 639 + ], + "lines": [ + { + "bbox": [ + 105, + 624, + 226, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 226, + 641 + ], + "score": 1.0, + "content": "8 Acknowledgements", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 44 + }, + { + "type": "text", + "bbox": [ + 107, + 650, + 505, + 716 + ], + "lines": [ + { + "bbox": [ + 105, + 650, + 505, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 650, + 505, + 663 + ], + "score": 1.0, + "content": "This research was supported by Berkeley Deep Drive, Open Philanthropy, and the National Science", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 661, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 106, + 661, + 505, + 673 + ], + "score": 1.0, + "content": "Foundation under NSF:NRI #2024675. Part of this work was completed when Aravind Rajeswaran", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 672, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 672, + 505, + 685 + ], + "score": 1.0, + "content": "was a PhD student at the University of Washington, where he was supported by the J.P. Morgan PhD", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 684, + 505, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 684, + 505, + 695 + ], + "score": 1.0, + "content": "Fellowship in AI (2020-21). We also thank Luke Metz, Daniel Freeman, and anonymous reviewers for", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 694, + 506, + 707 + ], + "spans": [ + { + "bbox": [ + 105, + 694, + 506, + 707 + ], + "score": 1.0, + "content": "valuable feedback and discussions, as well as Justin Fu for assistance in setting up D4RL benchmarks,", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 704, + 422, + 718 + ], + "spans": [ + { + "bbox": [ + 105, + 704, + 422, + 718 + ], + "score": 1.0, + "content": "and Aviral Kumar for assistance with the CQL baselines and hyperparameters.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 47.5, + "bbox_fs": [ + 105, + 650, + 506, + 718 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 46, + 506, + 726 + ], + "lines": [ + { + "bbox": [ + 106, + 70, + 165, + 86 + ], + "spans": [ + { + "bbox": [ + 106, + 70, + 165, + 86 + ], + "score": 1.0, + "content": "References", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 109, + 90, + 507, + 104 + ], + "spans": [ + { + "bbox": [ + 109, + 90, + 507, + 104 + ], + "score": 1.0, + "content": "[1] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez,", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 126, + 100, + 506, + 115 + ], + "spans": [ + { + "bbox": [ + 126, + 100, + 506, + 115 + ], + "score": 1.0, + "content": "Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Informa-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 127, + 113, + 254, + 124 + ], + "spans": [ + { + "bbox": [ + 127, + 113, + 254, + 124 + ], + "score": 1.0, + "content": "tion Processing Systems, 2017.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 110, + 131, + 506, + 145 + ], + "spans": [ + { + "bbox": [ + 110, + 131, + 506, + 145 + ], + "score": 1.0, + "content": "[2] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 126, + 141, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 126, + 141, + 505, + 155 + ], + "score": 1.0, + "content": "Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 126, + 153, + 365, + 167 + ], + "spans": [ + { + "bbox": [ + 126, + 153, + 365, + 167 + ], + "score": 1.0, + "content": "few-shot learners. arXiv preprint arXiv:2005.14165, 2020.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 111, + 173, + 505, + 185 + ], + "spans": [ + { + "bbox": [ + 111, + 173, + 505, + 185 + ], + "score": 1.0, + "content": "[3] Aditya Ramesh, Mikhail Pavlov, Gabriel Goh, Scott Gray, Chelsea Voss, Alec Radford, Mark", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 126, + 182, + 506, + 197 + ], + "spans": [ + { + "bbox": [ + 126, + 182, + 506, + 197 + ], + "score": 1.0, + "content": "Chen, and Ilya Sutskever. Zero-shot text-to-image generation. arXiv preprint arXiv:2102.12092,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 126, + 191, + 155, + 208 + ], + "spans": [ + { + "bbox": [ + 126, + 191, + 155, + 208 + ], + "score": 1.0, + "content": "2021.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 110, + 213, + 506, + 226 + ], + "spans": [ + { + "bbox": [ + 110, + 213, + 506, + 226 + ], + "score": 1.0, + "content": "[4] Emilio Parisotto, Francis Song, Jack Rae, Razvan Pascanu, Caglar Gulcehre, Siddhant Jayaku-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 126, + 223, + 506, + 238 + ], + "spans": [ + { + "bbox": [ + 126, + 223, + 506, + 238 + ], + "score": 1.0, + "content": "mar, Max Jaderberg, Raphael Lopez Kaufman, Aidan Clark, Seb Noury, et al. Stabilizing", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 125, + 233, + 508, + 250 + ], + "spans": [ + { + "bbox": [ + 125, + 233, + 508, + 250 + ], + "score": 1.0, + "content": "transformers for reinforcement learning. In International Conference on Machine Learning,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 127, + 245, + 154, + 259 + ], + "spans": [ + { + "bbox": [ + 127, + 245, + 154, + 259 + ], + "score": 1.0, + "content": "2020.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 110, + 263, + 506, + 279 + ], + "spans": [ + { + "bbox": [ + 110, + 263, + 506, + 279 + ], + "score": 1.0, + "content": "[5] Vinicius Zambaldi, David Raposo, Adam Santoro, Victor Bapst, Yujia Li, Igor Babuschkin, Karl", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 126, + 273, + 507, + 291 + ], + "spans": [ + { + "bbox": [ + 126, + 273, + 507, + 291 + ], + "score": 1.0, + "content": "Tuyls, David Reichert, Timothy Lillicrap, Edward Lockhart, et al. Deep reinforcement learning", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 126, + 286, + 507, + 300 + ], + "spans": [ + { + "bbox": [ + 126, + 286, + 507, + 300 + ], + "score": 1.0, + "content": "with relational inductive biases. In International Conference on Learning Representations,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 126, + 294, + 155, + 312 + ], + "spans": [ + { + "bbox": [ + 126, + 294, + 155, + 312 + ], + "score": 1.0, + "content": "2018.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 111, + 317, + 506, + 329 + ], + "spans": [ + { + "bbox": [ + 111, + 317, + 506, + 329 + ], + "score": 1.0, + "content": "[6] Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT Press,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 126, + 327, + 155, + 342 + ], + "spans": [ + { + "bbox": [ + 126, + 327, + 155, + 342 + ], + "score": 1.0, + "content": "2018.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 110, + 345, + 506, + 360 + ], + "spans": [ + { + "bbox": [ + 110, + 345, + 506, + 360 + ], + "score": 1.0, + "content": "[7] Chia-Chun Hung, Timothy Lillicrap, Josh Abramson, Yan Wu, Mehdi Mirza, Federico", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 127, + 357, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 127, + 357, + 505, + 371 + ], + "score": 1.0, + "content": "Carnevale, Arun Ahuja, and Greg Wayne. Optimizing agent behavior over long time scales by", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 126, + 368, + 381, + 381 + ], + "spans": [ + { + "bbox": [ + 126, + 368, + 381, + 381 + ], + "score": 1.0, + "content": "transporting value. Nature communications, 10(1):1–12, 2019.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 111, + 388, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 111, + 388, + 505, + 400 + ], + "score": 1.0, + "content": "[8] Rupesh Kumar Srivastava, Pranav Shyam, Filipe Mutz, Wojciech Jaskowski, and Jürgen ´", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 126, + 398, + 506, + 412 + ], + "spans": [ + { + "bbox": [ + 126, + 398, + 506, + 412 + ], + "score": 1.0, + "content": "Schmidhuber. Training agents using upside-down reinforcement learning. arXiv preprint", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 126, + 407, + 230, + 421 + ], + "spans": [ + { + "bbox": [ + 126, + 407, + 230, + 421 + ], + "score": 1.0, + "content": "arXiv:1912.02877, 2019.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 110, + 426, + 505, + 441 + ], + "spans": [ + { + "bbox": [ + 110, + 426, + 505, + 441 + ], + "score": 1.0, + "content": "[9] Aviral Kumar, Xue Bin Peng, and Sergey Levine. Reward-conditioned policies. arXiv preprint", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 126, + 438, + 232, + 451 + ], + "spans": [ + { + "bbox": [ + 126, + 438, + 232, + 451 + ], + "score": 1.0, + "content": "arXiv:1912.13465, 2019.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 455, + 506, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 251, + 471 + ], + "score": 1.0, + "content": "[10] Acting without rewards.", + "type": "text" + }, + { + "bbox": [ + 282, + 456, + 311, + 471 + ], + "score": 1.0, + "content": "2019.", + "type": "text" + }, + { + "bbox": [ + 342, + 455, + 506, + 472 + ], + "score": 1.0, + "content": "URL https://ogma.ai/2019/08/", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 126, + 468, + 255, + 482 + ], + "spans": [ + { + "bbox": [ + 126, + 468, + 255, + 482 + ], + "score": 1.0, + "content": "acting-without-rewards/.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 487, + 507, + 501 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 507, + 501 + ], + "score": 1.0, + "content": "[11] Sergey Levine, Aviral Kumar, George Tucker, and Justin Fu. Offline reinforcement learning:", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 126, + 498, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 126, + 498, + 505, + 512 + ], + "score": 1.0, + "content": "Tutorial, review, and perspectives on open problems. arXiv preprint arXiv:2005.01643, 2020.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 104, + 515, + 506, + 533 + ], + "spans": [ + { + "bbox": [ + 104, + 515, + 506, + 533 + ], + "score": 1.0, + "content": "[12] Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 126, + 529, + 321, + 541 + ], + "spans": [ + { + "bbox": [ + 126, + 529, + 321, + 541 + ], + "score": 1.0, + "content": "understanding by generative pre-training. 2018.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 545, + 506, + 562 + ], + "spans": [ + { + "bbox": [ + 104, + 545, + 506, + 562 + ], + "score": 1.0, + "content": "[13] Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 128, + 559, + 504, + 570 + ], + "spans": [ + { + "bbox": [ + 128, + 559, + 504, + 570 + ], + "score": 1.0, + "content": "environment: An evaluation platform for general agents. Journal of Artificial Intelligence", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 127, + 570, + 247, + 582 + ], + "spans": [ + { + "bbox": [ + 127, + 570, + 247, + 582 + ], + "score": 1.0, + "content": "Research, 47:253–279, 2013.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 104, + 586, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 104, + 586, + 506, + 603 + ], + "score": 1.0, + "content": "[14] Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 126, + 599, + 444, + 613 + ], + "spans": [ + { + "bbox": [ + 126, + 599, + 444, + 613 + ], + "score": 1.0, + "content": "and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 618, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 506, + 632 + ], + "score": 1.0, + "content": "[15] Thomas Mesnard, Théophane Weber, Fabio Viola, Shantanu Thakoor, Alaa Saade, Anna", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 127, + 629, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 127, + 629, + 505, + 643 + ], + "score": 1.0, + "content": "Harutyunyan, Will Dabney, Tom Stepleton, Nicolas Heess, Arthur Guez, et al. Counterfactual", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 126, + 640, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 126, + 640, + 505, + 654 + ], + "score": 1.0, + "content": "credit assignment in model-free reinforcement learning. arXiv preprint arXiv:2011.09464,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 126, + 650, + 154, + 664 + ], + "spans": [ + { + "bbox": [ + 126, + 650, + 154, + 664 + ], + "score": 1.0, + "content": "2020.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 104, + 669, + 506, + 684 + ], + "spans": [ + { + "bbox": [ + 104, + 669, + 506, + 684 + ], + "score": 1.0, + "content": "[16] Rishabh Agarwal, Dale Schuurmans, and Mohammad Norouzi. An optimistic perspective on", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 126, + 681, + 483, + 695 + ], + "spans": [ + { + "bbox": [ + 126, + 681, + 483, + 695 + ], + "score": 1.0, + "content": "offline reinforcement learning. In International Conference on Machine Learning, 2020.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 104, + 700, + 505, + 714 + ], + "spans": [ + { + "bbox": [ + 104, + 700, + 505, + 714 + ], + "score": 1.0, + "content": "[17] Aviral Kumar, Aurick Zhou, George Tucker, and Sergey Levine. Conservative q-learning for", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 126, + 711, + 503, + 725 + ], + "spans": [ + { + "bbox": [ + 126, + 711, + 503, + 725 + ], + "score": 1.0, + "content": "offline reinforcement learning. In Advances in Neural Information Processing Systems, 2020.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 23 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 310, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 312, + 755 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 312, + 755 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 106, + 46, + 506, + 726 + ], + "lines": [ + { + "bbox": [ + 106, + 70, + 165, + 86 + ], + "spans": [ + { + "bbox": [ + 106, + 70, + 165, + 86 + ], + "score": 1.0, + "content": "References", + "type": "text" + } + ], + "index": 0, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 109, + 90, + 507, + 104 + ], + "spans": [ + { + "bbox": [ + 109, + 90, + 507, + 104 + ], + "score": 1.0, + "content": "[1] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez,", + "type": "text" + } + ], + "index": 1, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 100, + 506, + 115 + ], + "spans": [ + { + "bbox": [ + 126, + 100, + 506, + 115 + ], + "score": 1.0, + "content": "Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Informa-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 127, + 113, + 254, + 124 + ], + "spans": [ + { + "bbox": [ + 127, + 113, + 254, + 124 + ], + "score": 1.0, + "content": "tion Processing Systems, 2017.", + "type": "text" + } + ], + "index": 3, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 131, + 506, + 145 + ], + "spans": [ + { + "bbox": [ + 110, + 131, + 506, + 145 + ], + "score": 1.0, + "content": "[2] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal,", + "type": "text" + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 141, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 126, + 141, + 505, + 155 + ], + "score": 1.0, + "content": "Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 126, + 153, + 365, + 167 + ], + "spans": [ + { + "bbox": [ + 126, + 153, + 365, + 167 + ], + "score": 1.0, + "content": "few-shot learners. arXiv preprint arXiv:2005.14165, 2020.", + "type": "text" + } + ], + "index": 6, + "is_list_end_line": true + }, + { + "bbox": [ + 111, + 173, + 505, + 185 + ], + "spans": [ + { + "bbox": [ + 111, + 173, + 505, + 185 + ], + "score": 1.0, + "content": "[3] Aditya Ramesh, Mikhail Pavlov, Gabriel Goh, Scott Gray, Chelsea Voss, Alec Radford, Mark", + "type": "text" + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 182, + 506, + 197 + ], + "spans": [ + { + "bbox": [ + 126, + 182, + 506, + 197 + ], + "score": 1.0, + "content": "Chen, and Ilya Sutskever. Zero-shot text-to-image generation. arXiv preprint arXiv:2102.12092,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 126, + 191, + 155, + 208 + ], + "spans": [ + { + "bbox": [ + 126, + 191, + 155, + 208 + ], + "score": 1.0, + "content": "2021.", + "type": "text" + } + ], + "index": 9, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 213, + 506, + 226 + ], + "spans": [ + { + "bbox": [ + 110, + 213, + 506, + 226 + ], + "score": 1.0, + "content": "[4] Emilio Parisotto, Francis Song, Jack Rae, Razvan Pascanu, Caglar Gulcehre, Siddhant Jayaku-", + "type": "text" + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 223, + 506, + 238 + ], + "spans": [ + { + "bbox": [ + 126, + 223, + 506, + 238 + ], + "score": 1.0, + "content": "mar, Max Jaderberg, Raphael Lopez Kaufman, Aidan Clark, Seb Noury, et al. Stabilizing", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 125, + 233, + 508, + 250 + ], + "spans": [ + { + "bbox": [ + 125, + 233, + 508, + 250 + ], + "score": 1.0, + "content": "transformers for reinforcement learning. In International Conference on Machine Learning,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 127, + 245, + 154, + 259 + ], + "spans": [ + { + "bbox": [ + 127, + 245, + 154, + 259 + ], + "score": 1.0, + "content": "2020.", + "type": "text" + } + ], + "index": 13, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 263, + 506, + 279 + ], + "spans": [ + { + "bbox": [ + 110, + 263, + 506, + 279 + ], + "score": 1.0, + "content": "[5] Vinicius Zambaldi, David Raposo, Adam Santoro, Victor Bapst, Yujia Li, Igor Babuschkin, Karl", + "type": "text" + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 273, + 507, + 291 + ], + "spans": [ + { + "bbox": [ + 126, + 273, + 507, + 291 + ], + "score": 1.0, + "content": "Tuyls, David Reichert, Timothy Lillicrap, Edward Lockhart, et al. Deep reinforcement learning", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 126, + 286, + 507, + 300 + ], + "spans": [ + { + "bbox": [ + 126, + 286, + 507, + 300 + ], + "score": 1.0, + "content": "with relational inductive biases. In International Conference on Learning Representations,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 126, + 294, + 155, + 312 + ], + "spans": [ + { + "bbox": [ + 126, + 294, + 155, + 312 + ], + "score": 1.0, + "content": "2018.", + "type": "text" + } + ], + "index": 17, + "is_list_end_line": true + }, + { + "bbox": [ + 111, + 317, + 506, + 329 + ], + "spans": [ + { + "bbox": [ + 111, + 317, + 506, + 329 + ], + "score": 1.0, + "content": "[6] Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT Press,", + "type": "text" + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 327, + 155, + 342 + ], + "spans": [ + { + "bbox": [ + 126, + 327, + 155, + 342 + ], + "score": 1.0, + "content": "2018.", + "type": "text" + } + ], + "index": 19, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 345, + 506, + 360 + ], + "spans": [ + { + "bbox": [ + 110, + 345, + 506, + 360 + ], + "score": 1.0, + "content": "[7] Chia-Chun Hung, Timothy Lillicrap, Josh Abramson, Yan Wu, Mehdi Mirza, Federico", + "type": "text" + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 357, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 127, + 357, + 505, + 371 + ], + "score": 1.0, + "content": "Carnevale, Arun Ahuja, and Greg Wayne. Optimizing agent behavior over long time scales by", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 126, + 368, + 381, + 381 + ], + "spans": [ + { + "bbox": [ + 126, + 368, + 381, + 381 + ], + "score": 1.0, + "content": "transporting value. Nature communications, 10(1):1–12, 2019.", + "type": "text" + } + ], + "index": 22, + "is_list_end_line": true + }, + { + "bbox": [ + 111, + 388, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 111, + 388, + 505, + 400 + ], + "score": 1.0, + "content": "[8] Rupesh Kumar Srivastava, Pranav Shyam, Filipe Mutz, Wojciech Jaskowski, and Jürgen ´", + "type": "text" + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 398, + 506, + 412 + ], + "spans": [ + { + "bbox": [ + 126, + 398, + 506, + 412 + ], + "score": 1.0, + "content": "Schmidhuber. Training agents using upside-down reinforcement learning. arXiv preprint", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 126, + 407, + 230, + 421 + ], + "spans": [ + { + "bbox": [ + 126, + 407, + 230, + 421 + ], + "score": 1.0, + "content": "arXiv:1912.02877, 2019.", + "type": "text" + } + ], + "index": 25, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 426, + 505, + 441 + ], + "spans": [ + { + "bbox": [ + 110, + 426, + 505, + 441 + ], + "score": 1.0, + "content": "[9] Aviral Kumar, Xue Bin Peng, and Sergey Levine. Reward-conditioned policies. arXiv preprint", + "type": "text" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 438, + 232, + 451 + ], + "spans": [ + { + "bbox": [ + 126, + 438, + 232, + 451 + ], + "score": 1.0, + "content": "arXiv:1912.13465, 2019.", + "type": "text" + } + ], + "index": 27, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 455, + 506, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 251, + 471 + ], + "score": 1.0, + "content": "[10] Acting without rewards.", + "type": "text" + }, + { + "bbox": [ + 282, + 456, + 311, + 471 + ], + "score": 1.0, + "content": "2019.", + "type": "text" + }, + { + "bbox": [ + 342, + 455, + 506, + 472 + ], + "score": 1.0, + "content": "URL https://ogma.ai/2019/08/", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 468, + 255, + 482 + ], + "spans": [ + { + "bbox": [ + 126, + 468, + 255, + 482 + ], + "score": 1.0, + "content": "acting-without-rewards/.", + "type": "text" + } + ], + "index": 29, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 487, + 507, + 501 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 507, + 501 + ], + "score": 1.0, + "content": "[11] Sergey Levine, Aviral Kumar, George Tucker, and Justin Fu. Offline reinforcement learning:", + "type": "text" + } + ], + "index": 30, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 498, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 126, + 498, + 505, + 512 + ], + "score": 1.0, + "content": "Tutorial, review, and perspectives on open problems. arXiv preprint arXiv:2005.01643, 2020.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 104, + 515, + 506, + 533 + ], + "spans": [ + { + "bbox": [ + 104, + 515, + 506, + 533 + ], + "score": 1.0, + "content": "[12] Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language", + "type": "text" + } + ], + "index": 32, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 529, + 321, + 541 + ], + "spans": [ + { + "bbox": [ + 126, + 529, + 321, + 541 + ], + "score": 1.0, + "content": "understanding by generative pre-training. 2018.", + "type": "text" + } + ], + "index": 33, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 545, + 506, + 562 + ], + "spans": [ + { + "bbox": [ + 104, + 545, + 506, + 562 + ], + "score": 1.0, + "content": "[13] Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning", + "type": "text" + } + ], + "index": 34, + "is_list_start_line": true + }, + { + "bbox": [ + 128, + 559, + 504, + 570 + ], + "spans": [ + { + "bbox": [ + 128, + 559, + 504, + 570 + ], + "score": 1.0, + "content": "environment: An evaluation platform for general agents. Journal of Artificial Intelligence", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 127, + 570, + 247, + 582 + ], + "spans": [ + { + "bbox": [ + 127, + 570, + 247, + 582 + ], + "score": 1.0, + "content": "Research, 47:253–279, 2013.", + "type": "text" + } + ], + "index": 36, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 586, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 104, + 586, + 506, + 603 + ], + "score": 1.0, + "content": "[14] Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang,", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 599, + 444, + 613 + ], + "spans": [ + { + "bbox": [ + 126, + 599, + 444, + 613 + ], + "score": 1.0, + "content": "and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016.", + "type": "text" + } + ], + "index": 38, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 618, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 506, + 632 + ], + "score": 1.0, + "content": "[15] Thomas Mesnard, Théophane Weber, Fabio Viola, Shantanu Thakoor, Alaa Saade, Anna", + "type": "text" + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 629, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 127, + 629, + 505, + 643 + ], + "score": 1.0, + "content": "Harutyunyan, Will Dabney, Tom Stepleton, Nicolas Heess, Arthur Guez, et al. Counterfactual", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 126, + 640, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 126, + 640, + 505, + 654 + ], + "score": 1.0, + "content": "credit assignment in model-free reinforcement learning. arXiv preprint arXiv:2011.09464,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 126, + 650, + 154, + 664 + ], + "spans": [ + { + "bbox": [ + 126, + 650, + 154, + 664 + ], + "score": 1.0, + "content": "2020.", + "type": "text" + } + ], + "index": 42, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 669, + 506, + 684 + ], + "spans": [ + { + "bbox": [ + 104, + 669, + 506, + 684 + ], + "score": 1.0, + "content": "[16] Rishabh Agarwal, Dale Schuurmans, and Mohammad Norouzi. An optimistic perspective on", + "type": "text" + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 681, + 483, + 695 + ], + "spans": [ + { + "bbox": [ + 126, + 681, + 483, + 695 + ], + "score": 1.0, + "content": "offline reinforcement learning. In International Conference on Machine Learning, 2020.", + "type": "text" + } + ], + "index": 44, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 700, + 505, + 714 + ], + "spans": [ + { + "bbox": [ + 104, + 700, + 505, + 714 + ], + "score": 1.0, + "content": "[17] Aviral Kumar, Aurick Zhou, George Tucker, and Sergey Levine. Conservative q-learning for", + "type": "text" + } + ], + "index": 45, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 711, + 503, + 725 + ], + "spans": [ + { + "bbox": [ + 126, + 711, + 503, + 725 + ], + "score": 1.0, + "content": "offline reinforcement learning. In Advances in Neural Information Processing Systems, 2020.", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 72, + 506, + 87 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 506, + 87 + ], + "score": 1.0, + "content": "[18] Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 83, + 232, + 97 + ], + "spans": [ + { + "bbox": [ + 126, + 83, + 232, + 97 + ], + "score": 1.0, + "content": "arXiv:1607.06450, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 1, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 101, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 104, + 101, + 506, + 118 + ], + "score": 1.0, + "content": "[19] Aviral Kumar, Justin Fu, George Tucker, and Sergey Levine. Stabilizing off-policy q-learning", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 114, + 428, + 127 + ], + "spans": [ + { + "bbox": [ + 126, + 114, + 428, + 127 + ], + "score": 1.0, + "content": "via bootstrapping error reduction. arXiv preprint arXiv:1906.00949, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 134, + 506, + 146 + ], + "spans": [ + { + "bbox": [ + 106, + 134, + 506, + 146 + ], + "score": 1.0, + "content": "[20] Yifan Wu, George Tucker, and Ofir Nachum. Behavior regularized offline reinforcement", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 144, + 329, + 159 + ], + "spans": [ + { + "bbox": [ + 127, + 144, + 329, + 159 + ], + "score": 1.0, + "content": "learning. arXiv preprint arXiv:1911.11361, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "score": 1.0, + "content": "[21] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G", + "type": "text", + "cross_page": true + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 176, + 506, + 188 + ], + "spans": [ + { + "bbox": [ + 127, + 176, + 506, + 188 + ], + "score": 1.0, + "content": "Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al.", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 127, + 185, + 506, + 200 + ], + "spans": [ + { + "bbox": [ + 127, + 185, + 506, + 200 + ], + "score": 1.0, + "content": "Human-level control through deep reinforcement learning. nature, 518(7540):529–533, 2015.", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 107, + 206, + 505, + 218 + ], + "spans": [ + { + "bbox": [ + 107, + 206, + 505, + 218 + ], + "score": 1.0, + "content": "[22] Danijar Hafner, Timothy Lillicrap, Mohammad Norouzi, and Jimmy Ba. Mastering atari with", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 216, + 385, + 230 + ], + "spans": [ + { + "bbox": [ + 126, + 216, + 385, + 230 + ], + "score": 1.0, + "content": "discrete world models. arXiv preprint arXiv:2010.02193, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 10, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 236, + 506, + 250 + ], + "spans": [ + { + "bbox": [ + 106, + 236, + 506, + 250 + ], + "score": 1.0, + "content": "[23] Will Dabney, Mark Rowland, Marc Bellemare, and Rémi Munos. Distributional reinforcement", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 248, + 450, + 260 + ], + "spans": [ + { + "bbox": [ + 127, + 248, + 450, + 260 + ], + "score": 1.0, + "content": "learning with quantile regression. In Conference on Artificial Intelligence, 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 12, + "is_list_end_line": true + }, + { + "bbox": [ + 107, + 267, + 506, + 279 + ], + "spans": [ + { + "bbox": [ + 107, + 267, + 506, + 279 + ], + "score": 1.0, + "content": "[24] Justin Fu, Aviral Kumar, Ofir Nachum, George Tucker, and Sergey Levine. D4rl: Datasets for", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 277, + 456, + 291 + ], + "spans": [ + { + "bbox": [ + 126, + 277, + 456, + 291 + ], + "score": 1.0, + "content": "deep data-driven reinforcement learning. arXiv preprint arXiv:2004.07219, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 14, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 297, + 506, + 311 + ], + "spans": [ + { + "bbox": [ + 106, + 297, + 506, + 311 + ], + "score": 1.0, + "content": "[25] Xue Bin Peng, Aviral Kumar, Grace Zhang, and Sergey Levine. Advantage-weighted regression:", + "type": "text", + "cross_page": true + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 307, + 506, + 322 + ], + "spans": [ + { + "bbox": [ + 127, + 307, + 506, + 322 + ], + "score": 1.0, + "content": "Simple and scalable off-policy reinforcement learning. arXiv preprint arXiv:1910.00177, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 326, + 506, + 341 + ], + "spans": [ + { + "bbox": [ + 106, + 326, + 506, + 341 + ], + "score": 1.0, + "content": "[26] David Raposo, Sam Ritter, Adam Santoro, Greg Wayne, Theophane Weber, Matt Botvinick,", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 338, + 506, + 352 + ], + "spans": [ + { + "bbox": [ + 127, + 338, + 506, + 352 + ], + "score": 1.0, + "content": "Hado van Hasselt, and Francis Song. Synthetic returns for long-term credit assignment. arXiv", + "type": "text", + "cross_page": true + } + ], + "index": 18 + }, + { + "bbox": [ + 125, + 349, + 267, + 362 + ], + "spans": [ + { + "bbox": [ + 125, + 349, + 267, + 362 + ], + "score": 1.0, + "content": "preprint arXiv:2102.12425, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 367, + 506, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 506, + 384 + ], + "score": 1.0, + "content": "[27] Scott Fujimoto, David Meger, and Doina Precup. Off-policy deep reinforcement learning", + "type": "text", + "cross_page": true + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 379, + 442, + 394 + ], + "spans": [ + { + "bbox": [ + 127, + 379, + 442, + 394 + ], + "score": 1.0, + "content": "without exploration. In International Conference on Machine Learning, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 21, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 399, + 506, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 399, + 506, + 414 + ], + "score": 1.0, + "content": "[28] Aviral Kumar, Justin Fu, Matthew Soh, George Tucker, and Sergey Levine. Stabilizing off-policy", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 125, + 408, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 125, + 408, + 506, + 426 + ], + "score": 1.0, + "content": "q-learning via bootstrapping error reduction. In Advances in Neural Information Processing", + "type": "text", + "cross_page": true + } + ], + "index": 23 + }, + { + "bbox": [ + 126, + 420, + 191, + 433 + ], + "spans": [ + { + "bbox": [ + 126, + 420, + 191, + 433 + ], + "score": 1.0, + "content": "Systems, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 24, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 440, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 506, + 455 + ], + "score": 1.0, + "content": "[29] Noah Y Siegel, Jost Tobias Springenberg, Felix Berkenkamp, Abbas Abdolmaleki, Michael", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 451, + 506, + 465 + ], + "spans": [ + { + "bbox": [ + 127, + 451, + 506, + 465 + ], + "score": 1.0, + "content": "Neunert, Thomas Lampe, Roland Hafner, and Martin Riedmiller. Keep doing what worked:", + "type": "text", + "cross_page": true + } + ], + "index": 26 + }, + { + "bbox": [ + 126, + 461, + 506, + 476 + ], + "spans": [ + { + "bbox": [ + 126, + 461, + 506, + 476 + ], + "score": 1.0, + "content": "Behavioral modelling priors for offline reinforcement learning. In International Conference on", + "type": "text", + "cross_page": true + } + ], + "index": 27 + }, + { + "bbox": [ + 127, + 474, + 261, + 486 + ], + "spans": [ + { + "bbox": [ + 127, + 474, + 261, + 486 + ], + "score": 1.0, + "content": "Learning Representations, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 28, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 492, + 506, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 506, + 507 + ], + "score": 1.0, + "content": "[30] Rahul Kidambi, Aravind Rajeswaran, Praneeth Netrapalli, and Thorsten Joachims. Morel:", + "type": "text", + "cross_page": true + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 504, + 506, + 518 + ], + "spans": [ + { + "bbox": [ + 127, + 504, + 506, + 518 + ], + "score": 1.0, + "content": "Model-based offline reinforcement learning. In Advances in Neural Information Processing", + "type": "text", + "cross_page": true + } + ], + "index": 30 + }, + { + "bbox": [ + 127, + 515, + 191, + 527 + ], + "spans": [ + { + "bbox": [ + 127, + 515, + 191, + 527 + ], + "score": 1.0, + "content": "Systems, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 31, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 535, + 506, + 547 + ], + "spans": [ + { + "bbox": [ + 106, + 535, + 506, + 547 + ], + "score": 1.0, + "content": "[31] Tianhe Yu, Garrett Thomas, Lantao Yu, Stefano Ermon, James Zou, Sergey Levine, Chelsea", + "type": "text", + "cross_page": true + } + ], + "index": 32, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 544, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 127, + 544, + 505, + 559 + ], + "score": 1.0, + "content": "Finn, and Tengyu Ma. Mopo: Model-based offline policy optimization. In Advances in Neural", + "type": "text", + "cross_page": true + } + ], + "index": 33 + }, + { + "bbox": [ + 127, + 557, + 286, + 569 + ], + "spans": [ + { + "bbox": [ + 127, + 557, + 286, + 569 + ], + "score": 1.0, + "content": "Information Processing Systems, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 34, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 574, + 506, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 506, + 589 + ], + "score": 1.0, + "content": "[32] Anurag Ajay, Aviral Kumar, Pulkit Agrawal, Sergey Levine, and Ofir Nachum. Opal: Of-", + "type": "text", + "cross_page": true + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 586, + 506, + 600 + ], + "spans": [ + { + "bbox": [ + 127, + 586, + 506, + 600 + ], + "score": 1.0, + "content": "fline primitive discovery for accelerating offline reinforcement learning. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 36 + }, + { + "bbox": [ + 126, + 597, + 232, + 610 + ], + "spans": [ + { + "bbox": [ + 126, + 597, + 232, + 610 + ], + "score": 1.0, + "content": "arXiv:2010.13611, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 37, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 617, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 506, + 631 + ], + "score": 1.0, + "content": "[33] Víctor Campos, Alexander Trott, Caiming Xiong, Richard Socher, Xavier Giro-i Nieto, and", + "type": "text", + "cross_page": true + } + ], + "index": 38, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 629, + 506, + 641 + ], + "spans": [ + { + "bbox": [ + 127, + 629, + 506, + 641 + ], + "score": 1.0, + "content": "Jordi Torres. Explore, discover and learn: Unsupervised discovery of state-covering skills. In", + "type": "text", + "cross_page": true + } + ], + "index": 39 + }, + { + "bbox": [ + 127, + 639, + 347, + 651 + ], + "spans": [ + { + "bbox": [ + 127, + 639, + 347, + 651 + ], + "score": 1.0, + "content": "International Conference on Machine Learning, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 40, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 658, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 658, + 505, + 672 + ], + "score": 1.0, + "content": "[34] Karl Pertsch, Youngwoon Lee, and Joseph J Lim. Accelerating reinforcement learning with", + "type": "text", + "cross_page": true + } + ], + "index": 41, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 670, + 370, + 682 + ], + "spans": [ + { + "bbox": [ + 127, + 670, + 370, + 682 + ], + "score": 1.0, + "content": "learned skill priors. arXiv preprint arXiv:2010.11944, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 42, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 688, + 506, + 703 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 703 + ], + "score": 1.0, + "content": "[35] Avi Singh, Huihan Liu, Gaoyue Zhou, Albert Yu, Nicholas Rhinehart, and Sergey Levine.", + "type": "text", + "cross_page": true + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 698, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 126, + 698, + 506, + 714 + ], + "score": 1.0, + "content": "Parrot: Data-driven behavioral priors for reinforcement learning. In International Conference", + "type": "text", + "cross_page": true + } + ], + "index": 44 + }, + { + "bbox": [ + 127, + 711, + 273, + 723 + ], + "spans": [ + { + "bbox": [ + 127, + 711, + 273, + 723 + ], + "score": 1.0, + "content": "on Learning Representations, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 45, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 73, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 106, + 73, + 505, + 85 + ], + "score": 1.0, + "content": "[36] Benjamin Eysenbach, Abhishek Gupta, Julian Ibarz, and Sergey Levine. Diversity is all you", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 82, + 507, + 99 + ], + "spans": [ + { + "bbox": [ + 126, + 82, + 507, + 99 + ], + "score": 1.0, + "content": "need: Learning skills without a reward function. In International Conference on Learning", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 127, + 95, + 221, + 107 + ], + "spans": [ + { + "bbox": [ + 127, + 95, + 221, + 107 + ], + "score": 1.0, + "content": "Representations, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 113, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 113, + 505, + 127 + ], + "score": 1.0, + "content": "[37] Kevin Lu, Aditya Grover, Pieter Abbeel, and Igor Mordatch. Reset-free lifelong learning with", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 128, + 125, + 375, + 137 + ], + "spans": [ + { + "bbox": [ + 128, + 125, + 375, + 137 + ], + "score": 1.0, + "content": "skill-space planning. arXiv preprint arXiv:2012.03548, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 142, + 507, + 156 + ], + "spans": [ + { + "bbox": [ + 106, + 142, + 507, + 156 + ], + "score": 1.0, + "content": "[38] Archit Sharma, Shixiang Gu, Sergey Levine, Vikash Kumar, and Karol Hausman. Dynamics-", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 154, + 506, + 166 + ], + "spans": [ + { + "bbox": [ + 127, + 154, + 506, + 166 + ], + "score": 1.0, + "content": "aware unsupervised discovery of skills. In International Conference on Learning Representa-", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 127, + 165, + 179, + 177 + ], + "spans": [ + { + "bbox": [ + 127, + 165, + 179, + 177 + ], + "score": 1.0, + "content": "tions, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 183, + 383, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 183, + 383, + 195 + ], + "score": 1.0, + "content": "[39] Christopher Watkins. Learning from delayed rewards. 01 1989.", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 200, + 506, + 214 + ], + "spans": [ + { + "bbox": [ + 104, + 200, + 506, + 214 + ], + "score": 1.0, + "content": "[40] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 212, + 506, + 226 + ], + "spans": [ + { + "bbox": [ + 127, + 212, + 506, + 226 + ], + "score": 1.0, + "content": "Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 127, + 224, + 226, + 236 + ], + "spans": [ + { + "bbox": [ + 127, + 224, + 226, + 236 + ], + "score": 1.0, + "content": "arXiv:1312.5602, 2013.", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 241, + 506, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 506, + 255 + ], + "score": 1.0, + "content": "[41] Mark Chen, Alec Radford, Rewon Child, Jeffrey Wu, Heewoo Jun, David Luan, and Ilya", + "type": "text", + "cross_page": true + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 251, + 506, + 266 + ], + "spans": [ + { + "bbox": [ + 126, + 251, + 506, + 266 + ], + "score": 1.0, + "content": "Sutskever. Generative pretraining from pixels. In International Conference on Machine", + "type": "text", + "cross_page": true + } + ], + "index": 13 + }, + { + "bbox": [ + 126, + 263, + 302, + 277 + ], + "spans": [ + { + "bbox": [ + 126, + 263, + 302, + 277 + ], + "score": 1.0, + "content": "Learning, pages 1691–1703. PMLR, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 14, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 282, + 505, + 294 + ], + "spans": [ + { + "bbox": [ + 106, + 282, + 505, + 294 + ], + "score": 1.0, + "content": "[42] Dibya Ghosh, Abhishek Gupta, Justin Fu, Ashwin Reddy, Coline Devin, Benjamin Eysenbach,", + "type": "text", + "cross_page": true + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 293, + 506, + 307 + ], + "spans": [ + { + "bbox": [ + 126, + 293, + 506, + 307 + ], + "score": 1.0, + "content": "and Sergey Levine. Learning to reach goals without reinforcement learning. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 16 + }, + { + "bbox": [ + 127, + 304, + 231, + 316 + ], + "spans": [ + { + "bbox": [ + 127, + 304, + 231, + 316 + ], + "score": 1.0, + "content": "arXiv:1912.06088, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 320, + 506, + 336 + ], + "spans": [ + { + "bbox": [ + 104, + 320, + 506, + 336 + ], + "score": 1.0, + "content": "[43] Keiran Paster, Sheila A McIlraith, and Jimmy Ba. Planning from pixels using inverse dynamics", + "type": "text", + "cross_page": true + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 334, + 325, + 345 + ], + "spans": [ + { + "bbox": [ + 127, + 334, + 325, + 345 + ], + "score": 1.0, + "content": "models. arXiv preprint arXiv:2012.02419, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 351, + 506, + 365 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 506, + 365 + ], + "score": 1.0, + "content": "[44] Michael Janner, Qiyang Li, and Sergey Levine. Reinforcement learning as one big sequence", + "type": "text", + "cross_page": true + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 362, + 370, + 376 + ], + "spans": [ + { + "bbox": [ + 126, + 362, + 370, + 376 + ], + "score": 1.0, + "content": "modeling problem. arXiv preprint arXiv:2106.02039, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 21, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 380, + 507, + 394 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 507, + 394 + ], + "score": 1.0, + "content": "[45] Johan Ferret, Raphaël Marinier, Matthieu Geist, and Olivier Pietquin. Self-attentional credit", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 392, + 492, + 406 + ], + "spans": [ + { + "bbox": [ + 126, + 392, + 492, + 406 + ], + "score": 1.0, + "content": "assignment for transfer in reinforcement learning. arXiv preprint arXiv:1907.08027, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 23, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 410, + 505, + 422 + ], + "spans": [ + { + "bbox": [ + 106, + 410, + 505, + 422 + ], + "score": 1.0, + "content": "[46] Anna Harutyunyan, Will Dabney, Thomas Mesnard, Mohammad Azar, Bilal Piot, Nicolas", + "type": "text", + "cross_page": true + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 128, + 421, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 128, + 421, + 505, + 433 + ], + "score": 1.0, + "content": "Heess, Hado van Hasselt, Greg Wayne, Satinder Singh, Doina Precup, et al. Hindsight credit", + "type": "text", + "cross_page": true + } + ], + "index": 25 + }, + { + "bbox": [ + 126, + 432, + 341, + 445 + ], + "spans": [ + { + "bbox": [ + 126, + 432, + 341, + 445 + ], + "score": 1.0, + "content": "assignment. arXiv preprint arXiv:1912.02503, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 26, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 450, + 506, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 506, + 464 + ], + "score": 1.0, + "content": "[47] Jose A Arjona-Medina, Michael Gillhofer, Michael Widrich, Thomas Unterthiner, Johannes", + "type": "text", + "cross_page": true + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 460, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 127, + 460, + 505, + 474 + ], + "score": 1.0, + "content": "Brandstetter, and Sepp Hochreiter. Rudder: Return decomposition for delayed rewards. arXiv", + "type": "text", + "cross_page": true + } + ], + "index": 28 + }, + { + "bbox": [ + 124, + 472, + 267, + 486 + ], + "spans": [ + { + "bbox": [ + 124, + 472, + 267, + 486 + ], + "score": 1.0, + "content": "preprint arXiv:1806.07857, 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 29, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 490, + 507, + 504 + ], + "spans": [ + { + "bbox": [ + 104, + 490, + 507, + 504 + ], + "score": 1.0, + "content": "[48] Yang Liu, Yunan Luo, Yuanyi Zhong, Xi Chen, Qiang Liu, and Jian Peng. Sequence mod-", + "type": "text", + "cross_page": true + } + ], + "index": 30, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 501, + 506, + 515 + ], + "spans": [ + { + "bbox": [ + 126, + 501, + 506, + 515 + ], + "score": 1.0, + "content": "eling of temporal credit assignment for episodic reinforcement learning. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 31 + }, + { + "bbox": [ + 125, + 512, + 231, + 526 + ], + "spans": [ + { + "bbox": [ + 125, + 512, + 231, + 526 + ], + "score": 1.0, + "content": "arXiv:1905.13420, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 32, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 530, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 104, + 530, + 506, + 545 + ], + "score": 1.0, + "content": "[49] Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative", + "type": "text", + "cross_page": true + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 543, + 484, + 555 + ], + "spans": [ + { + "bbox": [ + 127, + 543, + 484, + 555 + ], + "score": 1.0, + "content": "adversarial networks. In Conference on Computer Vision and Pattern Recognition, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 34, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 561, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 106, + 561, + 505, + 573 + ], + "score": 1.0, + "content": "[50] Marjan Ghazvininejad, Xing Shi, Jay Priyadarshi, and Kevin Knight. Hafez: an interactive", + "type": "text", + "cross_page": true + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 124, + 570, + 455, + 585 + ], + "spans": [ + { + "bbox": [ + 124, + 570, + 455, + 585 + ], + "score": 1.0, + "content": "poetry generation system. In Proceedings of ACL, System Demonstrations, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 36, + "is_list_end_line": true + }, + { + "bbox": [ + 103, + 586, + 507, + 605 + ], + "spans": [ + { + "bbox": [ + 103, + 586, + 192, + 605 + ], + "score": 1.0, + "content": "[51] Lilian Weng.", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 213, + 590, + 386, + 604 + ], + "score": 1.0, + "content": "Controllable neural text generation.", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 404, + 590, + 507, + 603 + ], + "score": 1.0, + "content": "lilianweng.github.io/lil-", + "type": "text", + "cross_page": true + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 599, + 506, + 616 + ], + "spans": [ + { + "bbox": [ + 126, + 601, + 188, + 614 + ], + "score": 1.0, + "content": "log, 2021.", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 215, + 599, + 506, + 616 + ], + "score": 1.0, + "content": "URL https://lilianweng.github.io/lil-log/2021/01/02/", + "type": "text", + "cross_page": true + } + ], + "index": 38 + }, + { + "bbox": [ + 128, + 613, + 345, + 624 + ], + "spans": [ + { + "bbox": [ + 128, + 613, + 345, + 624 + ], + "score": 1.0, + "content": "controllable-neural-text-generation.html.", + "type": "text", + "cross_page": true + } + ], + "index": 39, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 628, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 104, + 628, + 505, + 645 + ], + "score": 1.0, + "content": "[52] Jessica Ficler and Yoav Goldberg. Controlling linguistic style aspects in neural language", + "type": "text", + "cross_page": true + } + ], + "index": 40, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 641, + 339, + 654 + ], + "spans": [ + { + "bbox": [ + 126, + 641, + 339, + 654 + ], + "score": 1.0, + "content": "generation. arXiv preprint arXiv:1707.02633, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 41, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "[53] Zhiting Hu, Zichao Yang, Xiaodan Liang, Ruslan Salakhutdinov, and Eric P Xing. Toward", + "type": "text", + "cross_page": true + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 669, + 477, + 684 + ], + "spans": [ + { + "bbox": [ + 126, + 669, + 477, + 684 + ], + "score": 1.0, + "content": "controlled generation of text. In International Conference on Machine Learning, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 43, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 689, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 505, + 701 + ], + "score": 1.0, + "content": "[54] Nazneen Fatema Rajani, Bryan McCann, Caiming Xiong, and Richard Socher. Explain yourself!", + "type": "text", + "cross_page": true + } + ], + "index": 44, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 700, + 507, + 714 + ], + "spans": [ + { + "bbox": [ + 126, + 700, + 507, + 714 + ], + "score": 1.0, + "content": "leveraging language models for commonsense reasoning. arXiv preprint arXiv:1906.02361,", + "type": "text", + "cross_page": true + } + ], + "index": 45 + }, + { + "bbox": [ + 127, + 709, + 155, + 724 + ], + "spans": [ + { + "bbox": [ + 127, + 709, + 155, + 724 + ], + "score": 1.0, + "content": "2019.", + "type": "text", + "cross_page": true + } + ], + "index": 46, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 72, + 505, + 88 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 505, + 88 + ], + "score": 1.0, + "content": "[55] Lantao Yu, Weinan Zhang, Jun Wang, and Yong Yu. Seqgan: Sequence generative adversarial", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 84, + 439, + 97 + ], + "spans": [ + { + "bbox": [ + 127, + 84, + 439, + 97 + ], + "score": 1.0, + "content": "nets with policy gradient. In AAAI conference on artificial intelligence, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 1, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 102, + 506, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 102, + 506, + 117 + ], + "score": 1.0, + "content": "[56] Daniel M Ziegler, Nisan Stiennon, Jeffrey Wu, Tom B Brown, Alec Radford, Dario Amodei,", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 113, + 507, + 128 + ], + "spans": [ + { + "bbox": [ + 126, + 113, + 507, + 128 + ], + "score": 1.0, + "content": "Paul Christiano, and Geoffrey Irving. Fine-tuning language models from human preferences.", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 127, + 124, + 290, + 137 + ], + "spans": [ + { + "bbox": [ + 127, + 124, + 290, + 137 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1909.08593, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 143, + 507, + 157 + ], + "spans": [ + { + "bbox": [ + 105, + 143, + 507, + 157 + ], + "score": 1.0, + "content": "[57] Nitish Shirish Keskar, Bryan McCann, Lav R Varshney, Caiming Xiong, and Richard Socher.", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 153, + 506, + 169 + ], + "spans": [ + { + "bbox": [ + 126, + 153, + 506, + 169 + ], + "score": 1.0, + "content": "Ctrl: A conditional transformer language model for controllable generation. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 128, + 166, + 230, + 177 + ], + "spans": [ + { + "bbox": [ + 128, + 166, + 230, + 177 + ], + "score": 1.0, + "content": "arXiv:1909.05858, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 183, + 505, + 198 + ], + "spans": [ + { + "bbox": [ + 105, + 183, + 505, + 198 + ], + "score": 1.0, + "content": "[58] Sumanth Dathathri, Andrea Madotto, Janice Lan, Jane Hung, Eric Frank, Piero Molino, Jason", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 194, + 506, + 209 + ], + "spans": [ + { + "bbox": [ + 127, + 194, + 506, + 209 + ], + "score": 1.0, + "content": "Yosinski, and Rosanne Liu. Plug and play language models: A simple approach to controlled", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 127, + 205, + 356, + 220 + ], + "spans": [ + { + "bbox": [ + 127, + 205, + 356, + 220 + ], + "score": 1.0, + "content": "text generation. arXiv preprint arXiv:1912.02164, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 10, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 225, + 507, + 239 + ], + "spans": [ + { + "bbox": [ + 106, + 225, + 507, + 239 + ], + "score": 1.0, + "content": "[59] Ari Holtzman, Jan Buys, Maxwell Forbes, Antoine Bosselut, David Golub, and Yejin Choi.", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 235, + 494, + 249 + ], + "spans": [ + { + "bbox": [ + 127, + 235, + 494, + 249 + ], + "score": 1.0, + "content": "Learning to write with cooperative discriminators. arXiv preprint arXiv:1805.06087, 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 253, + 507, + 269 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 507, + 269 + ], + "score": 1.0, + "content": "[60] Ben Krause, Akhilesh Deepak Gotmare, Bryan McCann, Nitish Shirish Keskar, Shafiq Joty,", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 265, + 505, + 280 + ], + "spans": [ + { + "bbox": [ + 126, + 265, + 505, + 280 + ], + "score": 1.0, + "content": "Richard Socher, and Nazneen Fatema Rajani. Gedi: Generative discriminator guided sequence", + "type": "text", + "cross_page": true + } + ], + "index": 14 + }, + { + "bbox": [ + 127, + 277, + 339, + 289 + ], + "spans": [ + { + "bbox": [ + 127, + 277, + 339, + 289 + ], + "score": 1.0, + "content": "generation. arXiv preprint arXiv:2009.06367, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 15, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 294, + 506, + 309 + ], + "spans": [ + { + "bbox": [ + 106, + 294, + 506, + 309 + ], + "score": 1.0, + "content": "[61] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 305, + 506, + 320 + ], + "spans": [ + { + "bbox": [ + 126, + 305, + 506, + 320 + ], + "score": 1.0, + "content": "deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805,", + "type": "text", + "cross_page": true + } + ], + "index": 17 + }, + { + "bbox": [ + 126, + 316, + 154, + 330 + ], + "spans": [ + { + "bbox": [ + 126, + 316, + 154, + 330 + ], + "score": 1.0, + "content": "2018.", + "type": "text", + "cross_page": true + } + ], + "index": 18, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 335, + 506, + 350 + ], + "spans": [ + { + "bbox": [ + 106, + 335, + 506, + 350 + ], + "score": 1.0, + "content": "[62] Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 345, + 506, + 362 + ], + "spans": [ + { + "bbox": [ + 126, + 345, + 506, + 362 + ], + "score": 1.0, + "content": "Sergey Zagoruyko. End-to-end object detection with transformers. In European Conference on", + "type": "text", + "cross_page": true + } + ], + "index": 20 + }, + { + "bbox": [ + 127, + 357, + 225, + 371 + ], + "spans": [ + { + "bbox": [ + 127, + 357, + 225, + 371 + ], + "score": 1.0, + "content": "Computer Vision, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 21, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 375, + 507, + 390 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 507, + 390 + ], + "score": 1.0, + "content": "[63] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai,", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 388, + 506, + 401 + ], + "spans": [ + { + "bbox": [ + 127, + 388, + 506, + 401 + ], + "score": 1.0, + "content": "Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al.", + "type": "text", + "cross_page": true + } + ], + "index": 23 + }, + { + "bbox": [ + 126, + 398, + 506, + 413 + ], + "spans": [ + { + "bbox": [ + 126, + 398, + 506, + 413 + ], + "score": 1.0, + "content": "An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 24 + }, + { + "bbox": [ + 126, + 410, + 231, + 421 + ], + "spans": [ + { + "bbox": [ + 126, + 410, + 231, + 421 + ], + "score": 1.0, + "content": "arXiv:2010.11929, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 428, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 506, + 442 + ], + "score": 1.0, + "content": "[64] Sam Ritter, Ryan Faulkner, Laurent Sartran, Adam Santoro, Matt Botvinick, and David Raposo.", + "type": "text", + "cross_page": true + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 439, + 462, + 452 + ], + "spans": [ + { + "bbox": [ + 127, + 439, + 462, + 452 + ], + "score": 1.0, + "content": "Rapid task-solving in novel environments. arXiv preprint arXiv:2006.03662, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 27, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 458, + 506, + 472 + ], + "spans": [ + { + "bbox": [ + 106, + 458, + 506, + 472 + ], + "score": 1.0, + "content": "[65] Sudeep Dasari and Abhinav Gupta. Transformers for one-shot visual imitation. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 469, + 231, + 481 + ], + "spans": [ + { + "bbox": [ + 127, + 469, + 231, + 481 + ], + "score": 1.0, + "content": "arXiv:2011.05970, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 29, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 487, + 506, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 506, + 501 + ], + "score": 1.0, + "content": "[66] Josh Abramson, Arun Ahuja, Iain Barr, Arthur Brussee, Federico Carnevale, Mary Cassin,", + "type": "text", + "cross_page": true + } + ], + "index": 30, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 498, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 127, + 498, + 505, + 512 + ], + "score": 1.0, + "content": "Rachita Chhaparia, Stephen Clark, Bogdan Damoc, Andrew Dudzik, et al. Imitating interactive", + "type": "text", + "cross_page": true + } + ], + "index": 31 + }, + { + "bbox": [ + 126, + 509, + 343, + 523 + ], + "spans": [ + { + "bbox": [ + 126, + 509, + 343, + 523 + ], + "score": 1.0, + "content": "intelligence. arXiv preprint arXiv:2012.05672, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 32, + "is_list_end_line": true + } + ], + "index": 23, + "bbox_fs": [ + 104, + 70, + 508, + 725 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 104, + 30, + 507, + 727 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 506, + 87 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 506, + 87 + ], + "score": 1.0, + "content": "[18] Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 126, + 83, + 232, + 97 + ], + "spans": [ + { + "bbox": [ + 126, + 83, + 232, + 97 + ], + "score": 1.0, + "content": "arXiv:1607.06450, 2016.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 104, + 101, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 104, + 101, + 506, + 118 + ], + "score": 1.0, + "content": "[19] Aviral Kumar, Justin Fu, George Tucker, and Sergey Levine. Stabilizing off-policy q-learning", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 126, + 114, + 428, + 127 + ], + "spans": [ + { + "bbox": [ + 126, + 114, + 428, + 127 + ], + "score": 1.0, + "content": "via bootstrapping error reduction. arXiv preprint arXiv:1906.00949, 2019.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 134, + 506, + 146 + ], + "spans": [ + { + "bbox": [ + 106, + 134, + 506, + 146 + ], + "score": 1.0, + "content": "[20] Yifan Wu, George Tucker, and Ofir Nachum. Behavior regularized offline reinforcement", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 127, + 144, + 329, + 159 + ], + "spans": [ + { + "bbox": [ + 127, + 144, + 329, + 159 + ], + "score": 1.0, + "content": "learning. arXiv preprint arXiv:1911.11361, 2019.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "score": 1.0, + "content": "[21] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 127, + 176, + 506, + 188 + ], + "spans": [ + { + "bbox": [ + 127, + 176, + 506, + 188 + ], + "score": 1.0, + "content": "Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 127, + 185, + 506, + 200 + ], + "spans": [ + { + "bbox": [ + 127, + 185, + 506, + 200 + ], + "score": 1.0, + "content": "Human-level control through deep reinforcement learning. nature, 518(7540):529–533, 2015.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 107, + 206, + 505, + 218 + ], + "spans": [ + { + "bbox": [ + 107, + 206, + 505, + 218 + ], + "score": 1.0, + "content": "[22] Danijar Hafner, Timothy Lillicrap, Mohammad Norouzi, and Jimmy Ba. Mastering atari with", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 126, + 216, + 385, + 230 + ], + "spans": [ + { + "bbox": [ + 126, + 216, + 385, + 230 + ], + "score": 1.0, + "content": "discrete world models. arXiv preprint arXiv:2010.02193, 2020.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 236, + 506, + 250 + ], + "spans": [ + { + "bbox": [ + 106, + 236, + 506, + 250 + ], + "score": 1.0, + "content": "[23] Will Dabney, Mark Rowland, Marc Bellemare, and Rémi Munos. Distributional reinforcement", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 127, + 248, + 450, + 260 + ], + "spans": [ + { + "bbox": [ + 127, + 248, + 450, + 260 + ], + "score": 1.0, + "content": "learning with quantile regression. In Conference on Artificial Intelligence, 2018.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 107, + 267, + 506, + 279 + ], + "spans": [ + { + "bbox": [ + 107, + 267, + 506, + 279 + ], + "score": 1.0, + "content": "[24] Justin Fu, Aviral Kumar, Ofir Nachum, George Tucker, and Sergey Levine. D4rl: Datasets for", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 126, + 277, + 456, + 291 + ], + "spans": [ + { + "bbox": [ + 126, + 277, + 456, + 291 + ], + "score": 1.0, + "content": "deep data-driven reinforcement learning. arXiv preprint arXiv:2004.07219, 2020.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 297, + 506, + 311 + ], + "spans": [ + { + "bbox": [ + 106, + 297, + 506, + 311 + ], + "score": 1.0, + "content": "[25] Xue Bin Peng, Aviral Kumar, Grace Zhang, and Sergey Levine. Advantage-weighted regression:", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 127, + 307, + 506, + 322 + ], + "spans": [ + { + "bbox": [ + 127, + 307, + 506, + 322 + ], + "score": 1.0, + "content": "Simple and scalable off-policy reinforcement learning. arXiv preprint arXiv:1910.00177, 2019.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 326, + 506, + 341 + ], + "spans": [ + { + "bbox": [ + 106, + 326, + 506, + 341 + ], + "score": 1.0, + "content": "[26] David Raposo, Sam Ritter, Adam Santoro, Greg Wayne, Theophane Weber, Matt Botvinick,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 127, + 338, + 506, + 352 + ], + "spans": [ + { + "bbox": [ + 127, + 338, + 506, + 352 + ], + "score": 1.0, + "content": "Hado van Hasselt, and Francis Song. Synthetic returns for long-term credit assignment. arXiv", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 125, + 349, + 267, + 362 + ], + "spans": [ + { + "bbox": [ + 125, + 349, + 267, + 362 + ], + "score": 1.0, + "content": "preprint arXiv:2102.12425, 2021.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 367, + 506, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 506, + 384 + ], + "score": 1.0, + "content": "[27] Scott Fujimoto, David Meger, and Doina Precup. Off-policy deep reinforcement learning", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 127, + 379, + 442, + 394 + ], + "spans": [ + { + "bbox": [ + 127, + 379, + 442, + 394 + ], + "score": 1.0, + "content": "without exploration. In International Conference on Machine Learning, 2019.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 399, + 506, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 399, + 506, + 414 + ], + "score": 1.0, + "content": "[28] Aviral Kumar, Justin Fu, Matthew Soh, George Tucker, and Sergey Levine. Stabilizing off-policy", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 125, + 408, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 125, + 408, + 506, + 426 + ], + "score": 1.0, + "content": "q-learning via bootstrapping error reduction. In Advances in Neural Information Processing", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 126, + 420, + 191, + 433 + ], + "spans": [ + { + "bbox": [ + 126, + 420, + 191, + 433 + ], + "score": 1.0, + "content": "Systems, 2019.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 440, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 506, + 455 + ], + "score": 1.0, + "content": "[29] Noah Y Siegel, Jost Tobias Springenberg, Felix Berkenkamp, Abbas Abdolmaleki, Michael", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 127, + 451, + 506, + 465 + ], + "spans": [ + { + "bbox": [ + 127, + 451, + 506, + 465 + ], + "score": 1.0, + "content": "Neunert, Thomas Lampe, Roland Hafner, and Martin Riedmiller. Keep doing what worked:", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 126, + 461, + 506, + 476 + ], + "spans": [ + { + "bbox": [ + 126, + 461, + 506, + 476 + ], + "score": 1.0, + "content": "Behavioral modelling priors for offline reinforcement learning. In International Conference on", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 127, + 474, + 261, + 486 + ], + "spans": [ + { + "bbox": [ + 127, + 474, + 261, + 486 + ], + "score": 1.0, + "content": "Learning Representations, 2020.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 492, + 506, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 506, + 507 + ], + "score": 1.0, + "content": "[30] Rahul Kidambi, Aravind Rajeswaran, Praneeth Netrapalli, and Thorsten Joachims. Morel:", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 127, + 504, + 506, + 518 + ], + "spans": [ + { + "bbox": [ + 127, + 504, + 506, + 518 + ], + "score": 1.0, + "content": "Model-based offline reinforcement learning. In Advances in Neural Information Processing", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 127, + 515, + 191, + 527 + ], + "spans": [ + { + "bbox": [ + 127, + 515, + 191, + 527 + ], + "score": 1.0, + "content": "Systems, 2020.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 535, + 506, + 547 + ], + "spans": [ + { + "bbox": [ + 106, + 535, + 506, + 547 + ], + "score": 1.0, + "content": "[31] Tianhe Yu, Garrett Thomas, Lantao Yu, Stefano Ermon, James Zou, Sergey Levine, Chelsea", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 127, + 544, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 127, + 544, + 505, + 559 + ], + "score": 1.0, + "content": "Finn, and Tengyu Ma. Mopo: Model-based offline policy optimization. In Advances in Neural", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 127, + 557, + 286, + 569 + ], + "spans": [ + { + "bbox": [ + 127, + 557, + 286, + 569 + ], + "score": 1.0, + "content": "Information Processing Systems, 2020.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 574, + 506, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 506, + 589 + ], + "score": 1.0, + "content": "[32] Anurag Ajay, Aviral Kumar, Pulkit Agrawal, Sergey Levine, and Ofir Nachum. Opal: Of-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 127, + 586, + 506, + 600 + ], + "spans": [ + { + "bbox": [ + 127, + 586, + 506, + 600 + ], + "score": 1.0, + "content": "fline primitive discovery for accelerating offline reinforcement learning. arXiv preprint", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 126, + 597, + 232, + 610 + ], + "spans": [ + { + "bbox": [ + 126, + 597, + 232, + 610 + ], + "score": 1.0, + "content": "arXiv:2010.13611, 2020.", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 617, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 506, + 631 + ], + "score": 1.0, + "content": "[33] Víctor Campos, Alexander Trott, Caiming Xiong, Richard Socher, Xavier Giro-i Nieto, and", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 127, + 629, + 506, + 641 + ], + "spans": [ + { + "bbox": [ + 127, + 629, + 506, + 641 + ], + "score": 1.0, + "content": "Jordi Torres. Explore, discover and learn: Unsupervised discovery of state-covering skills. In", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 127, + 639, + 347, + 651 + ], + "spans": [ + { + "bbox": [ + 127, + 639, + 347, + 651 + ], + "score": 1.0, + "content": "International Conference on Machine Learning, 2020.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 658, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 658, + 505, + 672 + ], + "score": 1.0, + "content": "[34] Karl Pertsch, Youngwoon Lee, and Joseph J Lim. Accelerating reinforcement learning with", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 127, + 670, + 370, + 682 + ], + "spans": [ + { + "bbox": [ + 127, + 670, + 370, + 682 + ], + "score": 1.0, + "content": "learned skill priors. arXiv preprint arXiv:2010.11944, 2020.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 688, + 506, + 703 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 703 + ], + "score": 1.0, + "content": "[35] Avi Singh, Huihan Liu, Gaoyue Zhou, Albert Yu, Nicholas Rhinehart, and Sergey Levine.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 126, + 698, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 126, + 698, + 506, + 714 + ], + "score": 1.0, + "content": "Parrot: Data-driven behavioral priors for reinforcement learning. In International Conference", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 127, + 711, + 273, + 723 + ], + "spans": [ + { + "bbox": [ + 127, + 711, + 273, + 723 + ], + "score": 1.0, + "content": "on Learning Representations, 2021.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 22.5 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 311, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "score": 1.0, + "content": "12", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 104, + 30, + 507, + 727 + ], + "lines": [], + "index": 22.5, + "bbox_fs": [ + 104, + 72, + 506, + 723 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 46, + 507, + 724 + ], + "lines": [ + { + "bbox": [ + 106, + 73, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 106, + 73, + 505, + 85 + ], + "score": 1.0, + "content": "[36] Benjamin Eysenbach, Abhishek Gupta, Julian Ibarz, and Sergey Levine. Diversity is all you", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 126, + 82, + 507, + 99 + ], + "spans": [ + { + "bbox": [ + 126, + 82, + 507, + 99 + ], + "score": 1.0, + "content": "need: Learning skills without a reward function. In International Conference on Learning", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 127, + 95, + 221, + 107 + ], + "spans": [ + { + "bbox": [ + 127, + 95, + 221, + 107 + ], + "score": 1.0, + "content": "Representations, 2019.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 113, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 113, + 505, + 127 + ], + "score": 1.0, + "content": "[37] Kevin Lu, Aditya Grover, Pieter Abbeel, and Igor Mordatch. Reset-free lifelong learning with", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 128, + 125, + 375, + 137 + ], + "spans": [ + { + "bbox": [ + 128, + 125, + 375, + 137 + ], + "score": 1.0, + "content": "skill-space planning. arXiv preprint arXiv:2012.03548, 2020.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 142, + 507, + 156 + ], + "spans": [ + { + "bbox": [ + 106, + 142, + 507, + 156 + ], + "score": 1.0, + "content": "[38] Archit Sharma, Shixiang Gu, Sergey Levine, Vikash Kumar, and Karol Hausman. Dynamics-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 127, + 154, + 506, + 166 + ], + "spans": [ + { + "bbox": [ + 127, + 154, + 506, + 166 + ], + "score": 1.0, + "content": "aware unsupervised discovery of skills. In International Conference on Learning Representa-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 127, + 165, + 179, + 177 + ], + "spans": [ + { + "bbox": [ + 127, + 165, + 179, + 177 + ], + "score": 1.0, + "content": "tions, 2020.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 183, + 383, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 183, + 383, + 195 + ], + "score": 1.0, + "content": "[39] Christopher Watkins. Learning from delayed rewards. 01 1989.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 104, + 200, + 506, + 214 + ], + "spans": [ + { + "bbox": [ + 104, + 200, + 506, + 214 + ], + "score": 1.0, + "content": "[40] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 127, + 212, + 506, + 226 + ], + "spans": [ + { + "bbox": [ + 127, + 212, + 506, + 226 + ], + "score": 1.0, + "content": "Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 127, + 224, + 226, + 236 + ], + "spans": [ + { + "bbox": [ + 127, + 224, + 226, + 236 + ], + "score": 1.0, + "content": "arXiv:1312.5602, 2013.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 241, + 506, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 506, + 255 + ], + "score": 1.0, + "content": "[41] Mark Chen, Alec Radford, Rewon Child, Jeffrey Wu, Heewoo Jun, David Luan, and Ilya", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 126, + 251, + 506, + 266 + ], + "spans": [ + { + "bbox": [ + 126, + 251, + 506, + 266 + ], + "score": 1.0, + "content": "Sutskever. Generative pretraining from pixels. In International Conference on Machine", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 126, + 263, + 302, + 277 + ], + "spans": [ + { + "bbox": [ + 126, + 263, + 302, + 277 + ], + "score": 1.0, + "content": "Learning, pages 1691–1703. PMLR, 2020.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 282, + 505, + 294 + ], + "spans": [ + { + "bbox": [ + 106, + 282, + 505, + 294 + ], + "score": 1.0, + "content": "[42] Dibya Ghosh, Abhishek Gupta, Justin Fu, Ashwin Reddy, Coline Devin, Benjamin Eysenbach,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 126, + 293, + 506, + 307 + ], + "spans": [ + { + "bbox": [ + 126, + 293, + 506, + 307 + ], + "score": 1.0, + "content": "and Sergey Levine. Learning to reach goals without reinforcement learning. arXiv preprint", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 127, + 304, + 231, + 316 + ], + "spans": [ + { + "bbox": [ + 127, + 304, + 231, + 316 + ], + "score": 1.0, + "content": "arXiv:1912.06088, 2019.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 320, + 506, + 336 + ], + "spans": [ + { + "bbox": [ + 104, + 320, + 506, + 336 + ], + "score": 1.0, + "content": "[43] Keiran Paster, Sheila A McIlraith, and Jimmy Ba. Planning from pixels using inverse dynamics", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 127, + 334, + 325, + 345 + ], + "spans": [ + { + "bbox": [ + 127, + 334, + 325, + 345 + ], + "score": 1.0, + "content": "models. arXiv preprint arXiv:2012.02419, 2020.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 351, + 506, + 365 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 506, + 365 + ], + "score": 1.0, + "content": "[44] Michael Janner, Qiyang Li, and Sergey Levine. Reinforcement learning as one big sequence", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 126, + 362, + 370, + 376 + ], + "spans": [ + { + "bbox": [ + 126, + 362, + 370, + 376 + ], + "score": 1.0, + "content": "modeling problem. arXiv preprint arXiv:2106.02039, 2021.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 380, + 507, + 394 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 507, + 394 + ], + "score": 1.0, + "content": "[45] Johan Ferret, Raphaël Marinier, Matthieu Geist, and Olivier Pietquin. Self-attentional credit", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 126, + 392, + 492, + 406 + ], + "spans": [ + { + "bbox": [ + 126, + 392, + 492, + 406 + ], + "score": 1.0, + "content": "assignment for transfer in reinforcement learning. arXiv preprint arXiv:1907.08027, 2019.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 410, + 505, + 422 + ], + "spans": [ + { + "bbox": [ + 106, + 410, + 505, + 422 + ], + "score": 1.0, + "content": "[46] Anna Harutyunyan, Will Dabney, Thomas Mesnard, Mohammad Azar, Bilal Piot, Nicolas", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 128, + 421, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 128, + 421, + 505, + 433 + ], + "score": 1.0, + "content": "Heess, Hado van Hasselt, Greg Wayne, Satinder Singh, Doina Precup, et al. Hindsight credit", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 126, + 432, + 341, + 445 + ], + "spans": [ + { + "bbox": [ + 126, + 432, + 341, + 445 + ], + "score": 1.0, + "content": "assignment. arXiv preprint arXiv:1912.02503, 2019.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 450, + 506, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 506, + 464 + ], + "score": 1.0, + "content": "[47] Jose A Arjona-Medina, Michael Gillhofer, Michael Widrich, Thomas Unterthiner, Johannes", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 127, + 460, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 127, + 460, + 505, + 474 + ], + "score": 1.0, + "content": "Brandstetter, and Sepp Hochreiter. Rudder: Return decomposition for delayed rewards. arXiv", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 124, + 472, + 267, + 486 + ], + "spans": [ + { + "bbox": [ + 124, + 472, + 267, + 486 + ], + "score": 1.0, + "content": "preprint arXiv:1806.07857, 2018.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 490, + 507, + 504 + ], + "spans": [ + { + "bbox": [ + 104, + 490, + 507, + 504 + ], + "score": 1.0, + "content": "[48] Yang Liu, Yunan Luo, Yuanyi Zhong, Xi Chen, Qiang Liu, and Jian Peng. Sequence mod-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 126, + 501, + 506, + 515 + ], + "spans": [ + { + "bbox": [ + 126, + 501, + 506, + 515 + ], + "score": 1.0, + "content": "eling of temporal credit assignment for episodic reinforcement learning. arXiv preprint", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 125, + 512, + 231, + 526 + ], + "spans": [ + { + "bbox": [ + 125, + 512, + 231, + 526 + ], + "score": 1.0, + "content": "arXiv:1905.13420, 2019.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 104, + 530, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 104, + 530, + 506, + 545 + ], + "score": 1.0, + "content": "[49] Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 127, + 543, + 484, + 555 + ], + "spans": [ + { + "bbox": [ + 127, + 543, + 484, + 555 + ], + "score": 1.0, + "content": "adversarial networks. In Conference on Computer Vision and Pattern Recognition, 2019.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 561, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 106, + 561, + 505, + 573 + ], + "score": 1.0, + "content": "[50] Marjan Ghazvininejad, Xing Shi, Jay Priyadarshi, and Kevin Knight. Hafez: an interactive", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 124, + 570, + 455, + 585 + ], + "spans": [ + { + "bbox": [ + 124, + 570, + 455, + 585 + ], + "score": 1.0, + "content": "poetry generation system. In Proceedings of ACL, System Demonstrations, 2017.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 103, + 586, + 507, + 605 + ], + "spans": [ + { + "bbox": [ + 103, + 586, + 192, + 605 + ], + "score": 1.0, + "content": "[51] Lilian Weng.", + "type": "text" + }, + { + "bbox": [ + 213, + 590, + 386, + 604 + ], + "score": 1.0, + "content": "Controllable neural text generation.", + "type": "text" + }, + { + "bbox": [ + 404, + 590, + 507, + 603 + ], + "score": 1.0, + "content": "lilianweng.github.io/lil-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 126, + 599, + 506, + 616 + ], + "spans": [ + { + "bbox": [ + 126, + 601, + 188, + 614 + ], + "score": 1.0, + "content": "log, 2021.", + "type": "text" + }, + { + "bbox": [ + 215, + 599, + 506, + 616 + ], + "score": 1.0, + "content": "URL https://lilianweng.github.io/lil-log/2021/01/02/", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 128, + 613, + 345, + 624 + ], + "spans": [ + { + "bbox": [ + 128, + 613, + 345, + 624 + ], + "score": 1.0, + "content": "controllable-neural-text-generation.html.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 104, + 628, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 104, + 628, + 505, + 645 + ], + "score": 1.0, + "content": "[52] Jessica Ficler and Yoav Goldberg. Controlling linguistic style aspects in neural language", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 126, + 641, + 339, + 654 + ], + "spans": [ + { + "bbox": [ + 126, + 641, + 339, + 654 + ], + "score": 1.0, + "content": "generation. arXiv preprint arXiv:1707.02633, 2017.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "[53] Zhiting Hu, Zichao Yang, Xiaodan Liang, Ruslan Salakhutdinov, and Eric P Xing. Toward", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 126, + 669, + 477, + 684 + ], + "spans": [ + { + "bbox": [ + 126, + 669, + 477, + 684 + ], + "score": 1.0, + "content": "controlled generation of text. In International Conference on Machine Learning, 2017.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 689, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 505, + 701 + ], + "score": 1.0, + "content": "[54] Nazneen Fatema Rajani, Bryan McCann, Caiming Xiong, and Richard Socher. Explain yourself!", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 126, + 700, + 507, + 714 + ], + "spans": [ + { + "bbox": [ + 126, + 700, + 507, + 714 + ], + "score": 1.0, + "content": "leveraging language models for commonsense reasoning. arXiv preprint arXiv:1906.02361,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 127, + 709, + 155, + 724 + ], + "spans": [ + { + "bbox": [ + 127, + 709, + 155, + 724 + ], + "score": 1.0, + "content": "2019.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 23 + } + ], + "page_idx": 12, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 311, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 312, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 312, + 754 + ], + "score": 1.0, + "content": "13", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 105, + 46, + 507, + 724 + ], + "lines": [], + "index": 23, + "bbox_fs": [ + 103, + 73, + 507, + 724 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 104, + 72, + 507, + 522 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 505, + 88 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 505, + 88 + ], + "score": 1.0, + "content": "[55] Lantao Yu, Weinan Zhang, Jun Wang, and Yong Yu. Seqgan: Sequence generative adversarial", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 127, + 84, + 439, + 97 + ], + "spans": [ + { + "bbox": [ + 127, + 84, + 439, + 97 + ], + "score": 1.0, + "content": "nets with policy gradient. In AAAI conference on artificial intelligence, 2017.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 102, + 506, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 102, + 506, + 117 + ], + "score": 1.0, + "content": "[56] Daniel M Ziegler, Nisan Stiennon, Jeffrey Wu, Tom B Brown, Alec Radford, Dario Amodei,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 126, + 113, + 507, + 128 + ], + "spans": [ + { + "bbox": [ + 126, + 113, + 507, + 128 + ], + "score": 1.0, + "content": "Paul Christiano, and Geoffrey Irving. Fine-tuning language models from human preferences.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 127, + 124, + 290, + 137 + ], + "spans": [ + { + "bbox": [ + 127, + 124, + 290, + 137 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1909.08593, 2019.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 143, + 507, + 157 + ], + "spans": [ + { + "bbox": [ + 105, + 143, + 507, + 157 + ], + "score": 1.0, + "content": "[57] Nitish Shirish Keskar, Bryan McCann, Lav R Varshney, Caiming Xiong, and Richard Socher.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 126, + 153, + 506, + 169 + ], + "spans": [ + { + "bbox": [ + 126, + 153, + 506, + 169 + ], + "score": 1.0, + "content": "Ctrl: A conditional transformer language model for controllable generation. arXiv preprint", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 128, + 166, + 230, + 177 + ], + "spans": [ + { + "bbox": [ + 128, + 166, + 230, + 177 + ], + "score": 1.0, + "content": "arXiv:1909.05858, 2019.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 183, + 505, + 198 + ], + "spans": [ + { + "bbox": [ + 105, + 183, + 505, + 198 + ], + "score": 1.0, + "content": "[58] Sumanth Dathathri, Andrea Madotto, Janice Lan, Jane Hung, Eric Frank, Piero Molino, Jason", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 127, + 194, + 506, + 209 + ], + "spans": [ + { + "bbox": [ + 127, + 194, + 506, + 209 + ], + "score": 1.0, + "content": "Yosinski, and Rosanne Liu. Plug and play language models: A simple approach to controlled", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 127, + 205, + 356, + 220 + ], + "spans": [ + { + "bbox": [ + 127, + 205, + 356, + 220 + ], + "score": 1.0, + "content": "text generation. arXiv preprint arXiv:1912.02164, 2019.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 225, + 507, + 239 + ], + "spans": [ + { + "bbox": [ + 106, + 225, + 507, + 239 + ], + "score": 1.0, + "content": "[59] Ari Holtzman, Jan Buys, Maxwell Forbes, Antoine Bosselut, David Golub, and Yejin Choi.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 127, + 235, + 494, + 249 + ], + "spans": [ + { + "bbox": [ + 127, + 235, + 494, + 249 + ], + "score": 1.0, + "content": "Learning to write with cooperative discriminators. arXiv preprint arXiv:1805.06087, 2018.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 253, + 507, + 269 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 507, + 269 + ], + "score": 1.0, + "content": "[60] Ben Krause, Akhilesh Deepak Gotmare, Bryan McCann, Nitish Shirish Keskar, Shafiq Joty,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 126, + 265, + 505, + 280 + ], + "spans": [ + { + "bbox": [ + 126, + 265, + 505, + 280 + ], + "score": 1.0, + "content": "Richard Socher, and Nazneen Fatema Rajani. Gedi: Generative discriminator guided sequence", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 127, + 277, + 339, + 289 + ], + "spans": [ + { + "bbox": [ + 127, + 277, + 339, + 289 + ], + "score": 1.0, + "content": "generation. arXiv preprint arXiv:2009.06367, 2020.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 294, + 506, + 309 + ], + "spans": [ + { + "bbox": [ + 106, + 294, + 506, + 309 + ], + "score": 1.0, + "content": "[61] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 126, + 305, + 506, + 320 + ], + "spans": [ + { + "bbox": [ + 126, + 305, + 506, + 320 + ], + "score": 1.0, + "content": "deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 126, + 316, + 154, + 330 + ], + "spans": [ + { + "bbox": [ + 126, + 316, + 154, + 330 + ], + "score": 1.0, + "content": "2018.", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 335, + 506, + 350 + ], + "spans": [ + { + "bbox": [ + 106, + 335, + 506, + 350 + ], + "score": 1.0, + "content": "[62] Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 126, + 345, + 506, + 362 + ], + "spans": [ + { + "bbox": [ + 126, + 345, + 506, + 362 + ], + "score": 1.0, + "content": "Sergey Zagoruyko. End-to-end object detection with transformers. In European Conference on", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 127, + 357, + 225, + 371 + ], + "spans": [ + { + "bbox": [ + 127, + 357, + 225, + 371 + ], + "score": 1.0, + "content": "Computer Vision, 2020.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 375, + 507, + 390 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 507, + 390 + ], + "score": 1.0, + "content": "[63] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 127, + 388, + 506, + 401 + ], + "spans": [ + { + "bbox": [ + 127, + 388, + 506, + 401 + ], + "score": 1.0, + "content": "Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 126, + 398, + 506, + 413 + ], + "spans": [ + { + "bbox": [ + 126, + 398, + 506, + 413 + ], + "score": 1.0, + "content": "An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 126, + 410, + 231, + 421 + ], + "spans": [ + { + "bbox": [ + 126, + 410, + 231, + 421 + ], + "score": 1.0, + "content": "arXiv:2010.11929, 2020.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 428, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 506, + 442 + ], + "score": 1.0, + "content": "[64] Sam Ritter, Ryan Faulkner, Laurent Sartran, Adam Santoro, Matt Botvinick, and David Raposo.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 127, + 439, + 462, + 452 + ], + "spans": [ + { + "bbox": [ + 127, + 439, + 462, + 452 + ], + "score": 1.0, + "content": "Rapid task-solving in novel environments. arXiv preprint arXiv:2006.03662, 2020.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 458, + 506, + 472 + ], + "spans": [ + { + "bbox": [ + 106, + 458, + 506, + 472 + ], + "score": 1.0, + "content": "[65] Sudeep Dasari and Abhinav Gupta. Transformers for one-shot visual imitation. arXiv preprint", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 127, + 469, + 231, + 481 + ], + "spans": [ + { + "bbox": [ + 127, + 469, + 231, + 481 + ], + "score": 1.0, + "content": "arXiv:2011.05970, 2020.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 487, + 506, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 506, + 501 + ], + "score": 1.0, + "content": "[66] Josh Abramson, Arun Ahuja, Iain Barr, Arthur Brussee, Federico Carnevale, Mary Cassin,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 127, + 498, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 127, + 498, + 505, + 512 + ], + "score": 1.0, + "content": "Rachita Chhaparia, Stephen Clark, Bogdan Damoc, Andrew Dudzik, et al. Imitating interactive", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 126, + 509, + 343, + 523 + ], + "spans": [ + { + "bbox": [ + 126, + 509, + 343, + 523 + ], + "score": 1.0, + "content": "intelligence. arXiv preprint arXiv:2012.05672, 2020.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 16 + } + ], + "page_idx": 13, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 311, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "score": 1.0, + "content": "14", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 104, + 72, + 507, + 522 + ], + "lines": [], + "index": 16, + "bbox_fs": [ + 105, + 72, + 507, + 523 + ], + "lines_deleted": true + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file