diff --git "a/parse/train/SyzVb3CcFX/SyzVb3CcFX_middle.json" "b/parse/train/SyzVb3CcFX/SyzVb3CcFX_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/SyzVb3CcFX/SyzVb3CcFX_middle.json" @@ -0,0 +1,49159 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 79, + 429, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 77, + 335, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 77, + 335, + 97 + ], + "score": 1.0, + "content": "TIME-AGNOSTIC PREDICTION:", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 97, + 429, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 97, + 429, + 117 + ], + "score": 1.0, + "content": "PREDICTING PREDICTABLE VIDEO FRAMES", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 114, + 135, + 196, + 158 + ], + "lines": [ + { + "bbox": [ + 114, + 134, + 198, + 148 + ], + "spans": [ + { + "bbox": [ + 114, + 134, + 198, + 148 + ], + "score": 1.0, + "content": "Dinesh Jayaraman", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 112, + 145, + 168, + 159 + ], + "spans": [ + { + "bbox": [ + 112, + 145, + 168, + 159 + ], + "score": 1.0, + "content": "UC Berkeley", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 227, + 135, + 293, + 157 + ], + "lines": [ + { + "bbox": [ + 226, + 134, + 294, + 147 + ], + "spans": [ + { + "bbox": [ + 226, + 134, + 294, + 147 + ], + "score": 1.0, + "content": "Frederik Ebert", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 226, + 144, + 282, + 159 + ], + "spans": [ + { + "bbox": [ + 226, + 144, + 282, + 159 + ], + "score": 1.0, + "content": "UC Berkeley", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 324, + 135, + 385, + 158 + ], + "lines": [ + { + "bbox": [ + 323, + 134, + 387, + 147 + ], + "spans": [ + { + "bbox": [ + 323, + 134, + 387, + 147 + ], + "score": 1.0, + "content": "Alyosha Efros", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 323, + 145, + 379, + 159 + ], + "spans": [ + { + "bbox": [ + 323, + 145, + 379, + 159 + ], + "score": 1.0, + "content": "UC Berkeley", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 416, + 136, + 478, + 158 + ], + "lines": [ + { + "bbox": [ + 415, + 133, + 480, + 149 + ], + "spans": [ + { + "bbox": [ + 415, + 133, + 480, + 149 + ], + "score": 1.0, + "content": "Sergey Levine", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 415, + 145, + 471, + 159 + ], + "spans": [ + { + "bbox": [ + 415, + 145, + 471, + 159 + ], + "score": 1.0, + "content": "UC Berkeley", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5 + }, + { + "type": "title", + "bbox": [ + 278, + 187, + 333, + 199 + ], + "lines": [ + { + "bbox": [ + 276, + 185, + 336, + 201 + ], + "spans": [ + { + "bbox": [ + 276, + 185, + 336, + 201 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 143, + 209, + 469, + 351 + ], + "lines": [ + { + "bbox": [ + 141, + 208, + 469, + 222 + ], + "spans": [ + { + "bbox": [ + 141, + 208, + 469, + 222 + ], + "score": 1.0, + "content": "Prediction is arguably one of the most basic functions of an intelligent system. In", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 140, + 219, + 470, + 234 + ], + "spans": [ + { + "bbox": [ + 140, + 219, + 470, + 234 + ], + "score": 1.0, + "content": "general, the problem of predicting events in the future or between two waypoints is", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 231, + 470, + 244 + ], + "spans": [ + { + "bbox": [ + 141, + 231, + 470, + 244 + ], + "score": 1.0, + "content": "exceedingly difficult. However, most phenomena naturally pass through relatively", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 242, + 470, + 254 + ], + "spans": [ + { + "bbox": [ + 141, + 242, + 470, + 254 + ], + "score": 1.0, + "content": "predictable bottlenecks—while we cannot predict the precise trajectory of a robot", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 253, + 470, + 265 + ], + "spans": [ + { + "bbox": [ + 141, + 253, + 470, + 265 + ], + "score": 1.0, + "content": "arm between being at rest and holding an object up, we can be certain that it", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 264, + 469, + 276 + ], + "spans": [ + { + "bbox": [ + 141, + 264, + 469, + 276 + ], + "score": 1.0, + "content": "must have picked the object up. To exploit this, we decouple visual prediction", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 275, + 470, + 287 + ], + "spans": [ + { + "bbox": [ + 141, + 275, + 470, + 287 + ], + "score": 1.0, + "content": "from a rigid notion of time. While conventional approaches predict frames at", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 286, + 470, + 299 + ], + "spans": [ + { + "bbox": [ + 141, + 286, + 470, + 299 + ], + "score": 1.0, + "content": "regularly spaced temporal intervals, our time-agnostic predictors (TAP) are not tied", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 298, + 470, + 308 + ], + "spans": [ + { + "bbox": [ + 141, + 298, + 470, + 308 + ], + "score": 1.0, + "content": "to specific times so that they may instead discover predictable “bottleneck” frames", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 308, + 469, + 320 + ], + "spans": [ + { + "bbox": [ + 141, + 308, + 469, + 320 + ], + "score": 1.0, + "content": "no matter when they occur. We evaluate our approach for future and intermediate", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 142, + 319, + 469, + 331 + ], + "spans": [ + { + "bbox": [ + 142, + 319, + 469, + 331 + ], + "score": 1.0, + "content": "frame prediction across three robotic manipulation tasks. Our predictions are not", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 330, + 470, + 343 + ], + "spans": [ + { + "bbox": [ + 141, + 330, + 470, + 343 + ], + "score": 1.0, + "content": "only of higher visual quality, but also correspond to coherent semantic subgoals in", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 141, + 341, + 252, + 353 + ], + "spans": [ + { + "bbox": [ + 141, + 341, + 252, + 353 + ], + "score": 1.0, + "content": "temporally extended tasks.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 17 + }, + { + "type": "title", + "bbox": [ + 108, + 367, + 206, + 379 + ], + "lines": [ + { + "bbox": [ + 105, + 366, + 208, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 208, + 383 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 107, + 389, + 505, + 434 + ], + "lines": [ + { + "bbox": [ + 106, + 390, + 506, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 506, + 402 + ], + "score": 1.0, + "content": "Imagine taking a bottle of water and laying it on its side. Consider what happens to the surface of", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 401, + 505, + 413 + ], + "spans": [ + { + "bbox": [ + 106, + 401, + 505, + 413 + ], + "score": 1.0, + "content": "the water as you do this: which times can you confidently make predictions about? The surface is", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 411, + 506, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 506, + 424 + ], + "score": 1.0, + "content": "initially flat, then becomes turbulent, until it is flat again, as shown in Fig 1. Predicting the exact", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 423, + 506, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 423, + 506, + 435 + ], + "score": 1.0, + "content": "shape of the turbulent liquid is extremely hard, but its easy to say that it will eventually settle down.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 107, + 439, + 505, + 538 + ], + "lines": [ + { + "bbox": [ + 106, + 440, + 505, + 452 + ], + "spans": [ + { + "bbox": [ + 106, + 440, + 505, + 452 + ], + "score": 1.0, + "content": "Prediction is thought to be fundamental to intelligence (Bar, 2009; Clark, 2013; Hohwy, 2013). If an", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 450, + 506, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 506, + 463 + ], + "score": 1.0, + "content": "agent can learn to predict the future, it can take anticipatory actions, plan through its predictions, and", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 461, + 506, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 506, + 475 + ], + "score": 1.0, + "content": "use prediction as a proxy for representation learning. The key difficulty in prediction is uncertainty.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 471, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 486 + ], + "score": 1.0, + "content": "Visual prediction approaches attempt to mitigate uncertainty by predicting iteratively in heuristically", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 483, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 253, + 497 + ], + "score": 1.0, + "content": "chosen small timesteps, such as, say,", + "type": "text" + }, + { + "bbox": [ + 254, + 484, + 272, + 494 + ], + "score": 0.41, + "content": "0 . 1 s", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 483, + 505, + 497 + ], + "score": 1.0, + "content": ". In the bottle-tilting case, such approaches generate blurry", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 494, + 506, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 226, + 507 + ], + "score": 1.0, + "content": "images of the chaotic states at", + "type": "text" + }, + { + "bbox": [ + 226, + 495, + 300, + 506 + ], + "score": 0.75, + "content": "t = 0 . 1 s , 0 . 2 s , . . . ,", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 494, + 506, + 507 + ], + "score": 1.0, + "content": ", and this blurriness compounds to make predictions", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 505, + 506, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 506, + 518 + ], + "score": 1.0, + "content": "unusable within a few steps. Sophisticated probabilistic approaches have been proposed to better", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 516, + 506, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 506, + 529 + ], + "score": 1.0, + "content": "handle this uncertainty (Babaeizadeh et al., 2018; Lee et al., 2018; Denton & Fergus, 2018; Xue et al.,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 526, + 136, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 136, + 541 + ], + "score": 1.0, + "content": "2016).", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 107, + 544, + 505, + 621 + ], + "lines": [ + { + "bbox": [ + 106, + 544, + 505, + 557 + ], + "spans": [ + { + "bbox": [ + 106, + 544, + 505, + 557 + ], + "score": 1.0, + "content": "What if we instead change the goal of our prediction models? Fixed time intervals in prediction are", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 556, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 505, + 568 + ], + "score": 1.0, + "content": "in many ways an artifact of the fact that cameras and monitors record and display video at fixed", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 566, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 505, + 578 + ], + "score": 1.0, + "content": "frequencies. Rather than requiring predictions at regularly spaced future frames, we ask: if a frame", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 577, + 506, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 590 + ], + "score": 1.0, + "content": "prediction is treated as a bet on that frame occurring at some future point, what should we predict?", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 587, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 505, + 601 + ], + "score": 1.0, + "content": "Such time-agnostic prediction (TAP) has two immediate effects: (i) the predictor may skip more", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 600, + 504, + 610 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 504, + 610 + ], + "score": 1.0, + "content": "uncertain states in favor of less uncertain ones, and (ii) while in the standard approach, a prediction is", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 610, + 506, + 623 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 187, + 623 + ], + "score": 1.0, + "content": "wrong if it occurs at", + "type": "text" + }, + { + "bbox": [ + 188, + 611, + 209, + 620 + ], + "score": 0.87, + "content": "t \\pm \\epsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 209, + 610, + 264, + 623 + ], + "score": 1.0, + "content": "rather than at", + "type": "text" + }, + { + "bbox": [ + 264, + 611, + 269, + 620 + ], + "score": 0.73, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 610, + 506, + 623 + ], + "score": 1.0, + "content": ", our formulation considers such predictions equally correct.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 107, + 627, + 505, + 682 + ], + "lines": [ + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "Recall the bottle-tilting uncertainty profile. Fig 1 depicts uncertainty profiles for several other", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "prediction settings, including both forward/future prediction (given a start frame) and intermediate", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 648, + 506, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 506, + 662 + ], + "score": 1.0, + "content": "prediction (given start and end frames). Our time-agnostic reframing of the prediction problem targets", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 659, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 505, + 673 + ], + "score": 1.0, + "content": "the minima of these profiles, where prediction is intuitively easiest. We refer to these minima states", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 671, + 175, + 682 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 175, + 682 + ], + "score": 1.0, + "content": "as “bottlenecks.”", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 47 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "At this point, one might ask: are these “easy” bottlenecks actually useful to predict? Intuitively,", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "bottlenecks naturally correspond to reliable subgoals—an agent hoping to solve the maze in Fig 1 (e)", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "would do well to target its bottlenecks as subgoals. In our experiments, we evaluate the usefulness of", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 721, + 379, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 379, + 732 + ], + "score": 1.0, + "content": "our predictions as subgoals in simulated robotic manipulation tasks.", + "type": "text" + } + ], + "index": 53 + } + ], + "index": 51.5 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "1", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 79, + 429, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 77, + 335, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 77, + 335, + 97 + ], + "score": 1.0, + "content": "TIME-AGNOSTIC PREDICTION:", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 97, + 429, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 97, + 429, + 117 + ], + "score": 1.0, + "content": "PREDICTING PREDICTABLE VIDEO FRAMES", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 114, + 135, + 196, + 158 + ], + "lines": [ + { + "bbox": [ + 114, + 134, + 198, + 148 + ], + "spans": [ + { + "bbox": [ + 114, + 134, + 198, + 148 + ], + "score": 1.0, + "content": "Dinesh Jayaraman", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 112, + 145, + 168, + 159 + ], + "spans": [ + { + "bbox": [ + 112, + 145, + 168, + 159 + ], + "score": 1.0, + "content": "UC Berkeley", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5, + "bbox_fs": [ + 112, + 134, + 198, + 159 + ] + }, + { + "type": "text", + "bbox": [ + 227, + 135, + 293, + 157 + ], + "lines": [ + { + "bbox": [ + 226, + 134, + 294, + 147 + ], + "spans": [ + { + "bbox": [ + 226, + 134, + 294, + 147 + ], + "score": 1.0, + "content": "Frederik Ebert", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 226, + 144, + 282, + 159 + ], + "spans": [ + { + "bbox": [ + 226, + 144, + 282, + 159 + ], + "score": 1.0, + "content": "UC Berkeley", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5, + "bbox_fs": [ + 226, + 134, + 294, + 159 + ] + }, + { + "type": "text", + "bbox": [ + 324, + 135, + 385, + 158 + ], + "lines": [ + { + "bbox": [ + 323, + 134, + 387, + 147 + ], + "spans": [ + { + "bbox": [ + 323, + 134, + 387, + 147 + ], + "score": 1.0, + "content": "Alyosha Efros", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 323, + 145, + 379, + 159 + ], + "spans": [ + { + "bbox": [ + 323, + 145, + 379, + 159 + ], + "score": 1.0, + "content": "UC Berkeley", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5, + "bbox_fs": [ + 323, + 134, + 387, + 159 + ] + }, + { + "type": "text", + "bbox": [ + 416, + 136, + 478, + 158 + ], + "lines": [ + { + "bbox": [ + 415, + 133, + 480, + 149 + ], + "spans": [ + { + "bbox": [ + 415, + 133, + 480, + 149 + ], + "score": 1.0, + "content": "Sergey Levine", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 415, + 145, + 471, + 159 + ], + "spans": [ + { + "bbox": [ + 415, + 145, + 471, + 159 + ], + "score": 1.0, + "content": "UC Berkeley", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5, + "bbox_fs": [ + 415, + 133, + 480, + 159 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 187, + 333, + 199 + ], + "lines": [ + { + "bbox": [ + 276, + 185, + 336, + 201 + ], + "spans": [ + { + "bbox": [ + 276, + 185, + 336, + 201 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 143, + 209, + 469, + 351 + ], + "lines": [ + { + "bbox": [ + 141, + 208, + 469, + 222 + ], + "spans": [ + { + "bbox": [ + 141, + 208, + 469, + 222 + ], + "score": 1.0, + "content": "Prediction is arguably one of the most basic functions of an intelligent system. In", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 140, + 219, + 470, + 234 + ], + "spans": [ + { + "bbox": [ + 140, + 219, + 470, + 234 + ], + "score": 1.0, + "content": "general, the problem of predicting events in the future or between two waypoints is", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 231, + 470, + 244 + ], + "spans": [ + { + "bbox": [ + 141, + 231, + 470, + 244 + ], + "score": 1.0, + "content": "exceedingly difficult. However, most phenomena naturally pass through relatively", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 242, + 470, + 254 + ], + "spans": [ + { + "bbox": [ + 141, + 242, + 470, + 254 + ], + "score": 1.0, + "content": "predictable bottlenecks—while we cannot predict the precise trajectory of a robot", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 253, + 470, + 265 + ], + "spans": [ + { + "bbox": [ + 141, + 253, + 470, + 265 + ], + "score": 1.0, + "content": "arm between being at rest and holding an object up, we can be certain that it", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 264, + 469, + 276 + ], + "spans": [ + { + "bbox": [ + 141, + 264, + 469, + 276 + ], + "score": 1.0, + "content": "must have picked the object up. To exploit this, we decouple visual prediction", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 275, + 470, + 287 + ], + "spans": [ + { + "bbox": [ + 141, + 275, + 470, + 287 + ], + "score": 1.0, + "content": "from a rigid notion of time. While conventional approaches predict frames at", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 286, + 470, + 299 + ], + "spans": [ + { + "bbox": [ + 141, + 286, + 470, + 299 + ], + "score": 1.0, + "content": "regularly spaced temporal intervals, our time-agnostic predictors (TAP) are not tied", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 298, + 470, + 308 + ], + "spans": [ + { + "bbox": [ + 141, + 298, + 470, + 308 + ], + "score": 1.0, + "content": "to specific times so that they may instead discover predictable “bottleneck” frames", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 308, + 469, + 320 + ], + "spans": [ + { + "bbox": [ + 141, + 308, + 469, + 320 + ], + "score": 1.0, + "content": "no matter when they occur. We evaluate our approach for future and intermediate", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 142, + 319, + 469, + 331 + ], + "spans": [ + { + "bbox": [ + 142, + 319, + 469, + 331 + ], + "score": 1.0, + "content": "frame prediction across three robotic manipulation tasks. Our predictions are not", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 330, + 470, + 343 + ], + "spans": [ + { + "bbox": [ + 141, + 330, + 470, + 343 + ], + "score": 1.0, + "content": "only of higher visual quality, but also correspond to coherent semantic subgoals in", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 141, + 341, + 252, + 353 + ], + "spans": [ + { + "bbox": [ + 141, + 341, + 252, + 353 + ], + "score": 1.0, + "content": "temporally extended tasks.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 17, + "bbox_fs": [ + 140, + 208, + 470, + 353 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 367, + 206, + 379 + ], + "lines": [ + { + "bbox": [ + 105, + 366, + 208, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 208, + 383 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 107, + 389, + 505, + 434 + ], + "lines": [ + { + "bbox": [ + 106, + 390, + 506, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 506, + 402 + ], + "score": 1.0, + "content": "Imagine taking a bottle of water and laying it on its side. Consider what happens to the surface of", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 401, + 505, + 413 + ], + "spans": [ + { + "bbox": [ + 106, + 401, + 505, + 413 + ], + "score": 1.0, + "content": "the water as you do this: which times can you confidently make predictions about? The surface is", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 411, + 506, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 506, + 424 + ], + "score": 1.0, + "content": "initially flat, then becomes turbulent, until it is flat again, as shown in Fig 1. Predicting the exact", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 423, + 506, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 423, + 506, + 435 + ], + "score": 1.0, + "content": "shape of the turbulent liquid is extremely hard, but its easy to say that it will eventually settle down.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 390, + 506, + 435 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 439, + 505, + 538 + ], + "lines": [ + { + "bbox": [ + 106, + 440, + 505, + 452 + ], + "spans": [ + { + "bbox": [ + 106, + 440, + 505, + 452 + ], + "score": 1.0, + "content": "Prediction is thought to be fundamental to intelligence (Bar, 2009; Clark, 2013; Hohwy, 2013). If an", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 450, + 506, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 506, + 463 + ], + "score": 1.0, + "content": "agent can learn to predict the future, it can take anticipatory actions, plan through its predictions, and", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 461, + 506, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 506, + 475 + ], + "score": 1.0, + "content": "use prediction as a proxy for representation learning. The key difficulty in prediction is uncertainty.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 471, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 486 + ], + "score": 1.0, + "content": "Visual prediction approaches attempt to mitigate uncertainty by predicting iteratively in heuristically", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 483, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 253, + 497 + ], + "score": 1.0, + "content": "chosen small timesteps, such as, say,", + "type": "text" + }, + { + "bbox": [ + 254, + 484, + 272, + 494 + ], + "score": 0.41, + "content": "0 . 1 s", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 483, + 505, + 497 + ], + "score": 1.0, + "content": ". In the bottle-tilting case, such approaches generate blurry", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 494, + 506, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 226, + 507 + ], + "score": 1.0, + "content": "images of the chaotic states at", + "type": "text" + }, + { + "bbox": [ + 226, + 495, + 300, + 506 + ], + "score": 0.75, + "content": "t = 0 . 1 s , 0 . 2 s , . . . ,", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 494, + 506, + 507 + ], + "score": 1.0, + "content": ", and this blurriness compounds to make predictions", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 505, + 506, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 506, + 518 + ], + "score": 1.0, + "content": "unusable within a few steps. Sophisticated probabilistic approaches have been proposed to better", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 516, + 506, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 506, + 529 + ], + "score": 1.0, + "content": "handle this uncertainty (Babaeizadeh et al., 2018; Lee et al., 2018; Denton & Fergus, 2018; Xue et al.,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 526, + 136, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 136, + 541 + ], + "score": 1.0, + "content": "2016).", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 33, + "bbox_fs": [ + 105, + 440, + 506, + 541 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 544, + 505, + 621 + ], + "lines": [ + { + "bbox": [ + 106, + 544, + 505, + 557 + ], + "spans": [ + { + "bbox": [ + 106, + 544, + 505, + 557 + ], + "score": 1.0, + "content": "What if we instead change the goal of our prediction models? Fixed time intervals in prediction are", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 556, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 505, + 568 + ], + "score": 1.0, + "content": "in many ways an artifact of the fact that cameras and monitors record and display video at fixed", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 566, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 505, + 578 + ], + "score": 1.0, + "content": "frequencies. Rather than requiring predictions at regularly spaced future frames, we ask: if a frame", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 577, + 506, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 590 + ], + "score": 1.0, + "content": "prediction is treated as a bet on that frame occurring at some future point, what should we predict?", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 587, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 505, + 601 + ], + "score": 1.0, + "content": "Such time-agnostic prediction (TAP) has two immediate effects: (i) the predictor may skip more", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 600, + 504, + 610 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 504, + 610 + ], + "score": 1.0, + "content": "uncertain states in favor of less uncertain ones, and (ii) while in the standard approach, a prediction is", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 610, + 506, + 623 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 187, + 623 + ], + "score": 1.0, + "content": "wrong if it occurs at", + "type": "text" + }, + { + "bbox": [ + 188, + 611, + 209, + 620 + ], + "score": 0.87, + "content": "t \\pm \\epsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 209, + 610, + 264, + 623 + ], + "score": 1.0, + "content": "rather than at", + "type": "text" + }, + { + "bbox": [ + 264, + 611, + 269, + 620 + ], + "score": 0.73, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 610, + 506, + 623 + ], + "score": 1.0, + "content": ", our formulation considers such predictions equally correct.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 41, + "bbox_fs": [ + 105, + 544, + 506, + 623 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 627, + 505, + 682 + ], + "lines": [ + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "Recall the bottle-tilting uncertainty profile. Fig 1 depicts uncertainty profiles for several other", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "prediction settings, including both forward/future prediction (given a start frame) and intermediate", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 648, + 506, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 506, + 662 + ], + "score": 1.0, + "content": "prediction (given start and end frames). Our time-agnostic reframing of the prediction problem targets", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 659, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 505, + 673 + ], + "score": 1.0, + "content": "the minima of these profiles, where prediction is intuitively easiest. We refer to these minima states", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 671, + 175, + 682 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 175, + 682 + ], + "score": 1.0, + "content": "as “bottlenecks.”", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 47, + "bbox_fs": [ + 105, + 627, + 506, + 682 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "At this point, one might ask: are these “easy” bottlenecks actually useful to predict? Intuitively,", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "bottlenecks naturally correspond to reliable subgoals—an agent hoping to solve the maze in Fig 1 (e)", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "would do well to target its bottlenecks as subgoals. In our experiments, we evaluate the usefulness of", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 721, + 379, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 379, + 732 + ], + "score": 1.0, + "content": "our predictions as subgoals in simulated robotic manipulation tasks.", + "type": "text" + } + ], + "index": 53 + } + ], + "index": 51.5, + "bbox_fs": [ + 105, + 687, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 75, + 503, + 155 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 75, + 503, + 155 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 75, + 503, + 155 + ], + "spans": [ + { + "bbox": [ + 106, + 75, + 503, + 155 + ], + "score": 0.966, + "type": "image", + "image_path": "92f28243dd5787bef0b1258b64d2a01ce30a0854c5c61a880096ebae7320225f.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 75, + 503, + 101.66666666666667 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 101.66666666666667, + 503, + 128.33333333333334 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 128.33333333333334, + 503, + 155.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 163, + 505, + 213 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 163, + 504, + 173 + ], + "spans": [ + { + "bbox": [ + 106, + 163, + 504, + 173 + ], + "score": 1.0, + "content": "Figure 1: (a) Over time as the bottle is tilted, the uncertainty first rises and then falls as the bottle is held steady", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 172, + 506, + 184 + ], + "spans": [ + { + "bbox": [ + 105, + 172, + 506, + 184 + ], + "score": 1.0, + "content": "after tilting. (b)-(e) Similar uncertainty profiles corresponding to various scenarios—a ball rolling down the side", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 181, + 506, + 195 + ], + "spans": [ + { + "bbox": [ + 105, + 181, + 286, + 195 + ], + "score": 1.0, + "content": "of a bowl, a car driving on a highway with an exit", + "type": "text" + }, + { + "bbox": [ + 286, + 183, + 307, + 192 + ], + "score": 0.63, + "content": "1 0 0 \\mathrm { m }", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 181, + 506, + 195 + ], + "score": 1.0, + "content": "away, an iron pellet tossed in the direction of a magnet,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "score": 1.0, + "content": "and intermediate frame prediction in a maze traversal given start and end states. The red asterisks along the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 202, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 106, + 204, + 112, + 212 + ], + "score": 0.47, + "content": "\\mathbf { X } ^ { } -", + "type": "inline_equation" + }, + { + "bbox": [ + 113, + 202, + 505, + 214 + ], + "score": 1.0, + "content": "-axis correspond to the asterisks in the maze—these “bottleneck” states must occur in any successful traversal.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5 + } + ], + "index": 3.0 + }, + { + "type": "text", + "bbox": [ + 107, + 225, + 505, + 269 + ], + "lines": [ + { + "bbox": [ + 105, + 224, + 506, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 224, + 506, + 237 + ], + "score": 1.0, + "content": "Our main contributions are: (i) we reframe the video prediction problem to be time-agnostic, (ii) we", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 236, + 506, + 249 + ], + "spans": [ + { + "bbox": [ + 105, + 236, + 506, + 249 + ], + "score": 1.0, + "content": "propose a novel technical approach to solve this problem, (iii) we show that our approach effectively", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 246, + 505, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 505, + 259 + ], + "score": 1.0, + "content": "identifies “bottleneck states” across several tasks, and (iv) we show that these bottlenecks correspond", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 258, + 347, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 258, + 347, + 271 + ], + "score": 1.0, + "content": "to subgoals that aid in planning towards complex end goals.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9.5 + }, + { + "type": "title", + "bbox": [ + 108, + 286, + 211, + 299 + ], + "lines": [ + { + "bbox": [ + 104, + 285, + 213, + 302 + ], + "spans": [ + { + "bbox": [ + 104, + 285, + 213, + 302 + ], + "score": 1.0, + "content": "2 RELATED WORK", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 308, + 506, + 462 + ], + "lines": [ + { + "bbox": [ + 106, + 309, + 506, + 321 + ], + "spans": [ + { + "bbox": [ + 106, + 309, + 506, + 321 + ], + "score": 1.0, + "content": "Visual prediction approaches. Prior visual prediction approaches regress directly to future video", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 321, + 505, + 332 + ], + "spans": [ + { + "bbox": [ + 106, + 321, + 505, + 332 + ], + "score": 1.0, + "content": "frames in the pixel space (Ranzato et al., 2014; Oh et al., 2015) or in a learned feature space (Hadsell", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 331, + 506, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 506, + 343 + ], + "score": 1.0, + "content": "et al., 2006; Mobahi et al., 2009; Jayaraman & Grauman, 2015; Wang et al., 2016; Vondrick et al.,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 341, + 506, + 355 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 506, + 355 + ], + "score": 1.0, + "content": "2016b; Kitani et al., 2012). The success of generative adversarial networks (GANs) (Goodfellow", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 351, + 506, + 367 + ], + "spans": [ + { + "bbox": [ + 104, + 351, + 506, + 367 + ], + "score": 1.0, + "content": "et al., 2014; Mirza & Osindero, 2014; Radford et al., 2015; Isola et al., 2017) has inspired many", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 364, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 364, + 505, + 375 + ], + "score": 1.0, + "content": "video prediction approaches (Mathieu et al., 2015; Vondrick et al., 2016a; Finn & Levine, 2017; Xue", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 375, + 507, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 507, + 387 + ], + "score": 1.0, + "content": "et al., 2016; Oh et al., 2015; Ebert et al., 2017; Finn et al., 2016; Larsen et al., 2016; Lee et al., 2018).", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 386, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 506, + 399 + ], + "score": 1.0, + "content": "While adversarial losses aid in producing photorealistic image patches, prediction has to contend", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 396, + 506, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 506, + 409 + ], + "score": 1.0, + "content": "with a more fundamental problem: uncertainty. Several approaches (Walker et al., 2016; Xue et al.,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 407, + 506, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 407, + 506, + 420 + ], + "score": 1.0, + "content": "2016; Denton & Fergus, 2018; Lee et al., 2018; Larsen et al., 2016; Babaeizadeh et al., 2018) exploit", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 418, + 506, + 431 + ], + "spans": [ + { + "bbox": [ + 106, + 418, + 506, + 431 + ], + "score": 1.0, + "content": "conditional variational autoencoders (VAE) (Kingma & Welling, 2013) to train latent variable models", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 429, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 106, + 429, + 506, + 442 + ], + "score": 1.0, + "content": "for video prediction. Pixel-autoregression (Oord et al., 2016; van den Oord et al., 2016; Kalchbrenner", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 441, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 505, + 453 + ], + "score": 1.0, + "content": "et al., 2016) explicitly factorizes the joint distribution over all pixels to model uncertainty, at a high", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 452, + 187, + 464 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 187, + 464 + ], + "score": 1.0, + "content": "computational cost.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 107, + 468, + 505, + 524 + ], + "lines": [ + { + "bbox": [ + 105, + 468, + 505, + 481 + ], + "spans": [ + { + "bbox": [ + 105, + 468, + 505, + 481 + ], + "score": 1.0, + "content": "Like these prior approaches, we too address the uncertainty problem in video prediction. We propose", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 479, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 479, + 506, + 492 + ], + "score": 1.0, + "content": "a general time-agnostic prediction (TAP) framework for prediction tasks. While all prior work", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 490, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 490, + 505, + 502 + ], + "score": 1.0, + "content": "predicts at fixed time intervals, we aim to identify inherently low-uncertainty bottleneck frames with", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 502, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 505, + 514 + ], + "score": 1.0, + "content": "no associated timestamp. We show how TAP may be combined with conditional GANs as well as", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 512, + 340, + 525 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 340, + 525 + ], + "score": 1.0, + "content": "VAEs, to handle the residual uncertainty in its predictions.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 541, + 505, + 650 + ], + "lines": [ + { + "bbox": [ + 105, + 540, + 506, + 553 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 553 + ], + "score": 1.0, + "content": "Bottlenecks. In hierarchical reinforcement learning, bottlenecks are proposed for discovery of", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 552, + 506, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 506, + 564 + ], + "score": 1.0, + "content": "options (Sutton et al., 1999) in low-dimensional state spaces in (McGovern & Barto, 2001; S¸ ims¸ek", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 562, + 506, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 562, + 506, + 576 + ], + "score": 1.0, + "content": "& Barto, 2009; Bacon, 2013; Metzen, 2013). Most approaches (S¸ims¸ek & Barto, 2009; Bacon,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 573, + 505, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 505, + 586 + ], + "score": 1.0, + "content": "2013; Metzen, 2013) construct full transition graphs and apply notions of graph centrality to locate", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 584, + 505, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 505, + 598 + ], + "score": 1.0, + "content": "bottlenecks. A multi-instance learning approach is applied in (McGovern & Barto, 2001) to mine", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 595, + 505, + 607 + ], + "spans": [ + { + "bbox": [ + 106, + 595, + 505, + 607 + ], + "score": 1.0, + "content": "states that occur in successful trajectories but not in others. We consider the use of our bottleneck", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 606, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 104, + 606, + 506, + 619 + ], + "score": 1.0, + "content": "predictions as subgoals for a hierarchical planner, which is loosely related to options in that both aim", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 617, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 505, + 630 + ], + "score": 1.0, + "content": "to break down temporally extended trajectories into more manageable chunks. Unlike these prior", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 628, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 505, + 641 + ], + "score": 1.0, + "content": "works, we use predictability to identify bottlenecks, and apply this to unlabeled high-dimensional", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 640, + 202, + 651 + ], + "spans": [ + { + "bbox": [ + 106, + 640, + 202, + 651 + ], + "score": 1.0, + "content": "visual state trajectories.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 107, + 656, + 505, + 733 + ], + "lines": [ + { + "bbox": [ + 106, + 656, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 106, + 656, + 505, + 669 + ], + "score": 1.0, + "content": "Concurrently with us, Neitz et al. (2018) also propose a similar idea that allows a predictor to select", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 667, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 505, + 680 + ], + "score": 1.0, + "content": "when to predict, and their experiments demonstrate its advantages in specially constructed tasks with", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 678, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 506, + 691 + ], + "score": 1.0, + "content": "clear bottlenecks. In comparison, we propose not just the basic time-agnostic loss (Sec 3.1), but also", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 689, + 505, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 505, + 702 + ], + "score": 1.0, + "content": "improvements in Sec 3.2 through 3.5 that allow time-agnostic prediction to work in more general", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 699, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 713 + ], + "score": 1.0, + "content": "tasks such as synthetic and real videos of robotic object manipulation. Our experiments also test the", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 711, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 506, + 724 + ], + "score": 1.0, + "content": "quality of discovered bottlenecks in these scenarios and their usefulness as subgoals for hierarchical", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 104, + 721, + 147, + 737 + ], + "spans": [ + { + "bbox": [ + 104, + 721, + 147, + 737 + ], + "score": 1.0, + "content": "planning.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 45 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "score": 1.0, + "content": "2", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 75, + 503, + 155 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 75, + 503, + 155 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 75, + 503, + 155 + ], + "spans": [ + { + "bbox": [ + 106, + 75, + 503, + 155 + ], + "score": 0.966, + "type": "image", + "image_path": "92f28243dd5787bef0b1258b64d2a01ce30a0854c5c61a880096ebae7320225f.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 75, + 503, + 101.66666666666667 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 101.66666666666667, + 503, + 128.33333333333334 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 128.33333333333334, + 503, + 155.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 163, + 505, + 213 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 163, + 504, + 173 + ], + "spans": [ + { + "bbox": [ + 106, + 163, + 504, + 173 + ], + "score": 1.0, + "content": "Figure 1: (a) Over time as the bottle is tilted, the uncertainty first rises and then falls as the bottle is held steady", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 172, + 506, + 184 + ], + "spans": [ + { + "bbox": [ + 105, + 172, + 506, + 184 + ], + "score": 1.0, + "content": "after tilting. (b)-(e) Similar uncertainty profiles corresponding to various scenarios—a ball rolling down the side", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 181, + 506, + 195 + ], + "spans": [ + { + "bbox": [ + 105, + 181, + 286, + 195 + ], + "score": 1.0, + "content": "of a bowl, a car driving on a highway with an exit", + "type": "text" + }, + { + "bbox": [ + 286, + 183, + 307, + 192 + ], + "score": 0.63, + "content": "1 0 0 \\mathrm { m }", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 181, + 506, + 195 + ], + "score": 1.0, + "content": "away, an iron pellet tossed in the direction of a magnet,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "score": 1.0, + "content": "and intermediate frame prediction in a maze traversal given start and end states. The red asterisks along the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 202, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 106, + 204, + 112, + 212 + ], + "score": 0.47, + "content": "\\mathbf { X } ^ { } -", + "type": "inline_equation" + }, + { + "bbox": [ + 113, + 202, + 505, + 214 + ], + "score": 1.0, + "content": "-axis correspond to the asterisks in the maze—these “bottleneck” states must occur in any successful traversal.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5 + } + ], + "index": 3.0 + }, + { + "type": "text", + "bbox": [ + 107, + 225, + 505, + 269 + ], + "lines": [ + { + "bbox": [ + 105, + 224, + 506, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 224, + 506, + 237 + ], + "score": 1.0, + "content": "Our main contributions are: (i) we reframe the video prediction problem to be time-agnostic, (ii) we", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 236, + 506, + 249 + ], + "spans": [ + { + "bbox": [ + 105, + 236, + 506, + 249 + ], + "score": 1.0, + "content": "propose a novel technical approach to solve this problem, (iii) we show that our approach effectively", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 246, + 505, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 505, + 259 + ], + "score": 1.0, + "content": "identifies “bottleneck states” across several tasks, and (iv) we show that these bottlenecks correspond", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 258, + 347, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 258, + 347, + 271 + ], + "score": 1.0, + "content": "to subgoals that aid in planning towards complex end goals.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 224, + 506, + 271 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 286, + 211, + 299 + ], + "lines": [ + { + "bbox": [ + 104, + 285, + 213, + 302 + ], + "spans": [ + { + "bbox": [ + 104, + 285, + 213, + 302 + ], + "score": 1.0, + "content": "2 RELATED WORK", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 308, + 506, + 462 + ], + "lines": [ + { + "bbox": [ + 106, + 309, + 506, + 321 + ], + "spans": [ + { + "bbox": [ + 106, + 309, + 506, + 321 + ], + "score": 1.0, + "content": "Visual prediction approaches. Prior visual prediction approaches regress directly to future video", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 321, + 505, + 332 + ], + "spans": [ + { + "bbox": [ + 106, + 321, + 505, + 332 + ], + "score": 1.0, + "content": "frames in the pixel space (Ranzato et al., 2014; Oh et al., 2015) or in a learned feature space (Hadsell", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 331, + 506, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 506, + 343 + ], + "score": 1.0, + "content": "et al., 2006; Mobahi et al., 2009; Jayaraman & Grauman, 2015; Wang et al., 2016; Vondrick et al.,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 341, + 506, + 355 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 506, + 355 + ], + "score": 1.0, + "content": "2016b; Kitani et al., 2012). The success of generative adversarial networks (GANs) (Goodfellow", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 351, + 506, + 367 + ], + "spans": [ + { + "bbox": [ + 104, + 351, + 506, + 367 + ], + "score": 1.0, + "content": "et al., 2014; Mirza & Osindero, 2014; Radford et al., 2015; Isola et al., 2017) has inspired many", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 364, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 364, + 505, + 375 + ], + "score": 1.0, + "content": "video prediction approaches (Mathieu et al., 2015; Vondrick et al., 2016a; Finn & Levine, 2017; Xue", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 375, + 507, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 507, + 387 + ], + "score": 1.0, + "content": "et al., 2016; Oh et al., 2015; Ebert et al., 2017; Finn et al., 2016; Larsen et al., 2016; Lee et al., 2018).", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 386, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 506, + 399 + ], + "score": 1.0, + "content": "While adversarial losses aid in producing photorealistic image patches, prediction has to contend", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 396, + 506, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 506, + 409 + ], + "score": 1.0, + "content": "with a more fundamental problem: uncertainty. Several approaches (Walker et al., 2016; Xue et al.,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 407, + 506, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 407, + 506, + 420 + ], + "score": 1.0, + "content": "2016; Denton & Fergus, 2018; Lee et al., 2018; Larsen et al., 2016; Babaeizadeh et al., 2018) exploit", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 418, + 506, + 431 + ], + "spans": [ + { + "bbox": [ + 106, + 418, + 506, + 431 + ], + "score": 1.0, + "content": "conditional variational autoencoders (VAE) (Kingma & Welling, 2013) to train latent variable models", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 429, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 106, + 429, + 506, + 442 + ], + "score": 1.0, + "content": "for video prediction. Pixel-autoregression (Oord et al., 2016; van den Oord et al., 2016; Kalchbrenner", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 441, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 505, + 453 + ], + "score": 1.0, + "content": "et al., 2016) explicitly factorizes the joint distribution over all pixels to model uncertainty, at a high", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 452, + 187, + 464 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 187, + 464 + ], + "score": 1.0, + "content": "computational cost.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 19.5, + "bbox_fs": [ + 104, + 309, + 507, + 464 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 468, + 505, + 524 + ], + "lines": [ + { + "bbox": [ + 105, + 468, + 505, + 481 + ], + "spans": [ + { + "bbox": [ + 105, + 468, + 505, + 481 + ], + "score": 1.0, + "content": "Like these prior approaches, we too address the uncertainty problem in video prediction. We propose", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 479, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 479, + 506, + 492 + ], + "score": 1.0, + "content": "a general time-agnostic prediction (TAP) framework for prediction tasks. While all prior work", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 490, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 490, + 505, + 502 + ], + "score": 1.0, + "content": "predicts at fixed time intervals, we aim to identify inherently low-uncertainty bottleneck frames with", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 502, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 505, + 514 + ], + "score": 1.0, + "content": "no associated timestamp. We show how TAP may be combined with conditional GANs as well as", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 512, + 340, + 525 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 340, + 525 + ], + "score": 1.0, + "content": "VAEs, to handle the residual uncertainty in its predictions.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29, + "bbox_fs": [ + 105, + 468, + 506, + 525 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 541, + 505, + 650 + ], + "lines": [ + { + "bbox": [ + 105, + 540, + 506, + 553 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 553 + ], + "score": 1.0, + "content": "Bottlenecks. In hierarchical reinforcement learning, bottlenecks are proposed for discovery of", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 552, + 506, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 506, + 564 + ], + "score": 1.0, + "content": "options (Sutton et al., 1999) in low-dimensional state spaces in (McGovern & Barto, 2001; S¸ ims¸ek", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 562, + 506, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 562, + 506, + 576 + ], + "score": 1.0, + "content": "& Barto, 2009; Bacon, 2013; Metzen, 2013). Most approaches (S¸ims¸ek & Barto, 2009; Bacon,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 573, + 505, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 505, + 586 + ], + "score": 1.0, + "content": "2013; Metzen, 2013) construct full transition graphs and apply notions of graph centrality to locate", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 584, + 505, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 505, + 598 + ], + "score": 1.0, + "content": "bottlenecks. A multi-instance learning approach is applied in (McGovern & Barto, 2001) to mine", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 595, + 505, + 607 + ], + "spans": [ + { + "bbox": [ + 106, + 595, + 505, + 607 + ], + "score": 1.0, + "content": "states that occur in successful trajectories but not in others. We consider the use of our bottleneck", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 606, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 104, + 606, + 506, + 619 + ], + "score": 1.0, + "content": "predictions as subgoals for a hierarchical planner, which is loosely related to options in that both aim", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 617, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 505, + 630 + ], + "score": 1.0, + "content": "to break down temporally extended trajectories into more manageable chunks. Unlike these prior", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 628, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 505, + 641 + ], + "score": 1.0, + "content": "works, we use predictability to identify bottlenecks, and apply this to unlabeled high-dimensional", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 640, + 202, + 651 + ], + "spans": [ + { + "bbox": [ + 106, + 640, + 202, + 651 + ], + "score": 1.0, + "content": "visual state trajectories.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 36.5, + "bbox_fs": [ + 104, + 540, + 506, + 651 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 656, + 505, + 733 + ], + "lines": [ + { + "bbox": [ + 106, + 656, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 106, + 656, + 505, + 669 + ], + "score": 1.0, + "content": "Concurrently with us, Neitz et al. (2018) also propose a similar idea that allows a predictor to select", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 667, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 505, + 680 + ], + "score": 1.0, + "content": "when to predict, and their experiments demonstrate its advantages in specially constructed tasks with", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 678, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 506, + 691 + ], + "score": 1.0, + "content": "clear bottlenecks. In comparison, we propose not just the basic time-agnostic loss (Sec 3.1), but also", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 689, + 505, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 505, + 702 + ], + "score": 1.0, + "content": "improvements in Sec 3.2 through 3.5 that allow time-agnostic prediction to work in more general", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 699, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 713 + ], + "score": 1.0, + "content": "tasks such as synthetic and real videos of robotic object manipulation. Our experiments also test the", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 711, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 506, + 724 + ], + "score": 1.0, + "content": "quality of discovered bottlenecks in these scenarios and their usefulness as subgoals for hierarchical", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 104, + 721, + 147, + 737 + ], + "spans": [ + { + "bbox": [ + 104, + 721, + 147, + 737 + ], + "score": 1.0, + "content": "planning.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 45, + "bbox_fs": [ + 104, + 656, + 506, + 737 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 106, + 81, + 415, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 79, + 416, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 79, + 416, + 96 + ], + "score": 1.0, + "content": "3 TIME-AGNOSTIC PREDICTION OF BOTTLENECK FRAMES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 106, + 102, + 506, + 159 + ], + "lines": [ + { + "bbox": [ + 106, + 103, + 505, + 115 + ], + "spans": [ + { + "bbox": [ + 106, + 103, + 505, + 115 + ], + "score": 1.0, + "content": "In visual prediction, the goal is to predict a set of unobserved target video frames given some observed", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 115, + 507, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 507, + 127 + ], + "score": 1.0, + "content": "context frames. In forward prediction, the context is the first frame, and the target is all future frames.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 126, + 505, + 137 + ], + "spans": [ + { + "bbox": [ + 106, + 126, + 505, + 137 + ], + "score": 1.0, + "content": "In the bidirectionally conditioned prediction case, the context is the first and the last frame, and the", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 135, + 506, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 135, + 506, + 150 + ], + "score": 1.0, + "content": "frames in between are the target. In Fig 1, we may wish to predict future images of the tilting bottle,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 147, + 395, + 160 + ], + "spans": [ + { + "bbox": [ + 106, + 147, + 395, + 160 + ], + "score": 1.0, + "content": "or intermediate images of an agent who traverses the maze successfully.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3 + }, + { + "type": "title", + "bbox": [ + 108, + 171, + 255, + 183 + ], + "lines": [ + { + "bbox": [ + 106, + 171, + 256, + 184 + ], + "spans": [ + { + "bbox": [ + 106, + 171, + 256, + 184 + ], + "score": 1.0, + "content": "3.1 MINIMUM-OVER-TIME LOSS", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 190, + 298, + 289 + ], + "lines": [ + { + "bbox": [ + 106, + 190, + 298, + 202 + ], + "spans": [ + { + "bbox": [ + 106, + 190, + 298, + 202 + ], + "score": 1.0, + "content": "In standard fixed-time video prediction mod-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 201, + 298, + 213 + ], + "spans": [ + { + "bbox": [ + 106, + 201, + 298, + 213 + ], + "score": 1.0, + "content": "els (Ranzato et al., 2014; Oh et al., 2015; Math-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 212, + 298, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 212, + 298, + 223 + ], + "score": 1.0, + "content": "ieu et al., 2015; Vondrick et al., 2016a; Walker", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 223, + 298, + 235 + ], + "spans": [ + { + "bbox": [ + 105, + 223, + 298, + 235 + ], + "score": 1.0, + "content": "et al., 2016; Finn & Levine, 2017; Xue et al.,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 234, + 297, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 297, + 245 + ], + "score": 1.0, + "content": "2016; Oh et al., 2015; Ebert et al., 2017; Finn", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 245, + 299, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 299, + 257 + ], + "score": 1.0, + "content": "et al., 2016; Lee et al., 2018; Denton & Fergus,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 255, + 297, + 268 + ], + "spans": [ + { + "bbox": [ + 105, + 255, + 171, + 268 + ], + "score": 1.0, + "content": "2018), a frame", + "type": "text" + }, + { + "bbox": [ + 172, + 258, + 184, + 268 + ], + "score": 0.87, + "content": "x _ { \\tau }", + "type": "inline_equation" + }, + { + "bbox": [ + 184, + 255, + 275, + 268 + ], + "score": 1.0, + "content": "(video frame at time", + "type": "text" + }, + { + "bbox": [ + 275, + 258, + 282, + 267 + ], + "score": 0.63, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 283, + 255, + 297, + 268 + ], + "score": 1.0, + "content": ") is", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 267, + 297, + 279 + ], + "spans": [ + { + "bbox": [ + 106, + 267, + 297, + 279 + ], + "score": 1.0, + "content": "selected in advance to be the training target for", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 279, + 298, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 279, + 210, + 290 + ], + "score": 1.0, + "content": "some given input frames", + "type": "text" + }, + { + "bbox": [ + 211, + 281, + 217, + 288 + ], + "score": 0.59, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 279, + 298, + 290 + ], + "score": 1.0, + "content": ". For instance, in a", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 11 + }, + { + "type": "image", + "bbox": [ + 304, + 203, + 506, + 265 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 304, + 203, + 506, + 265 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 304, + 203, + 506, + 265 + ], + "spans": [ + { + "bbox": [ + 304, + 203, + 506, + 265 + ], + "score": 0.963, + "type": "image", + "image_path": "553b16ffacea6fe1931de7a05f2cd5a1dc88cc89a9ebb774a469ea6e63d25d18.jpg" + } + ] + } + ], + "index": 17.5, + "virtual_lines": [ + { + "bbox": [ + 304, + 203, + 506, + 218.5 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 304, + 218.5, + 506, + 234.0 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 304, + 234.0, + 506, + 249.5 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 304, + 249.5, + 506, + 265.0 + ], + "spans": [], + "index": 19 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 324, + 272, + 485, + 284 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 322, + 272, + 486, + 284 + ], + "spans": [ + { + "bbox": [ + 322, + 272, + 486, + 284 + ], + "score": 1.0, + "content": "Figure 2: The TAP minimum-over time loss.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + } + ], + "index": 18.75 + }, + { + "type": "text", + "bbox": [ + 106, + 290, + 503, + 312 + ], + "lines": [ + { + "bbox": [ + 105, + 288, + 503, + 304 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 302, + 304 + ], + "score": 1.0, + "content": "typical forward prediction setup, the input may be", + "type": "text" + }, + { + "bbox": [ + 302, + 291, + 331, + 300 + ], + "score": 0.88, + "content": "c = x _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 288, + 467, + 304 + ], + "score": 1.0, + "content": ", and the target frame may be set to", + "type": "text" + }, + { + "bbox": [ + 468, + 292, + 503, + 300 + ], + "score": 0.89, + "content": "x _ { \\tau } = x _ { 1 }", + "type": "inline_equation" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 299, + 492, + 314 + ], + "spans": [ + { + "bbox": [ + 105, + 299, + 154, + 314 + ], + "score": 1.0, + "content": "A predictor", + "type": "text" + }, + { + "bbox": [ + 155, + 301, + 164, + 310 + ], + "score": 0.83, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 299, + 249, + 314 + ], + "score": 1.0, + "content": "takes context frames", + "type": "text" + }, + { + "bbox": [ + 249, + 303, + 255, + 310 + ], + "score": 0.69, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 299, + 403, + 314 + ], + "score": 1.0, + "content": "as input and produces a single frame", + "type": "text" + }, + { + "bbox": [ + 404, + 300, + 424, + 312 + ], + "score": 0.87, + "content": "G ( c )", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 299, + 429, + 314 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 429, + 301, + 438, + 310 + ], + "score": 0.72, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 299, + 492, + 314 + ], + "score": 1.0, + "content": "is trained as:", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5 + }, + { + "type": "interline_equation", + "bbox": [ + 211, + 313, + 398, + 333 + ], + "lines": [ + { + "bbox": [ + 211, + 313, + 398, + 333 + ], + "spans": [ + { + "bbox": [ + 211, + 313, + 398, + 333 + ], + "score": 0.92, + "content": "G ^ { * } = \\underset { G } { \\arg \\operatorname* { m i n } } \\mathcal { L } _ { 0 } ( G ) = \\underset { G } { \\arg \\operatorname* { m i n } } \\mathcal { E } ( G ( c ) , x _ { \\tau } ) ,", + "type": "interline_equation", + "image_path": "7abefb258e6867e561fc04bab08fbf27c1ebcdb5a6e54c199e2e4aa67b5643ae.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 211, + 313, + 398, + 333 + ], + "spans": [], + "index": 23 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 334, + 505, + 357 + ], + "lines": [ + { + "bbox": [ + 105, + 332, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 133, + 347 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 335, + 141, + 344 + ], + "score": 0.8, + "content": "\\mathcal { E }", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 332, + 311, + 347 + ], + "score": 1.0, + "content": "is a measure of prediction error, such as", + "type": "text" + }, + { + "bbox": [ + 311, + 334, + 369, + 345 + ], + "score": 0.87, + "content": "\\| G ( c ) - x _ { \\tau } \\| _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 332, + 505, + 347 + ], + "score": 1.0, + "content": ".1 This predictor may be applied", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 345, + 466, + 358 + ], + "spans": [ + { + "bbox": [ + 106, + 345, + 326, + 358 + ], + "score": 1.0, + "content": "recursively at test time to generate more predictions as", + "type": "text" + }, + { + "bbox": [ + 326, + 345, + 418, + 357 + ], + "score": 0.81, + "content": "{ \\dot { G } } ( G ( c ) ) , G ( G ( G ( c ) ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 345, + 466, + 358 + ], + "score": 1.0, + "content": ", and so on.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 106, + 361, + 505, + 406 + ], + "lines": [ + { + "bbox": [ + 105, + 362, + 506, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 506, + 375 + ], + "score": 1.0, + "content": "We propose to depart from this fixed-time paradigm by decoupling prediction from a rigid notion of", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 372, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 357, + 385 + ], + "score": 1.0, + "content": "time. Instead of predicting the video frame at a specified time", + "type": "text" + }, + { + "bbox": [ + 357, + 375, + 364, + 383 + ], + "score": 0.76, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 372, + 505, + 385 + ], + "score": 1.0, + "content": ", we propose to predict predictable", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 384, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 505, + 397 + ], + "score": 1.0, + "content": "bottleneck video frames through a time-agnostic predictor (TAP), as motivated in Sec 1. To train this", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 395, + 370, + 407 + ], + "spans": [ + { + "bbox": [ + 106, + 395, + 370, + 407 + ], + "score": 1.0, + "content": "predictor, we minimize the following “minimum-over-time” loss:", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27.5 + }, + { + "type": "interline_equation", + "bbox": [ + 205, + 408, + 405, + 428 + ], + "lines": [ + { + "bbox": [ + 205, + 408, + 405, + 428 + ], + "spans": [ + { + "bbox": [ + 205, + 408, + 405, + 428 + ], + "score": 0.91, + "content": "G ^ { * } = \\underset { G } { \\arg \\operatorname* { m i n } } \\ : \\mathcal { L } ( G ) = \\underset { G } { \\arg \\operatorname* { m i n } } \\ : \\underset { t \\in \\mathrm { T } } { \\operatorname* { m i n } } \\ : \\mathcal { E } ( G ( c ) , x _ { t } ) ,", + "type": "interline_equation", + "image_path": "d13da1952f7635b0f6b8307cee21cbf2e9fcb49b6c92bea2025ccd8338a670b8.jpg" + } + ] + } + ], + "index": 30, + "virtual_lines": [ + { + "bbox": [ + 205, + 408, + 405, + 428 + ], + "spans": [], + "index": 30 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 428, + 505, + 505 + ], + "lines": [ + { + "bbox": [ + 105, + 427, + 506, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 231, + 439 + ], + "score": 1.0, + "content": "where the key difference from", + "type": "text" + }, + { + "bbox": [ + 232, + 428, + 252, + 439 + ], + "score": 0.26, + "content": "\\mathrm { E q ~ } 1", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 427, + 506, + 439 + ], + "score": 1.0, + "content": "is that the loss is now a minimum over target times of a time-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 438, + 505, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 438, + 164, + 451 + ], + "score": 1.0, + "content": "indexed error", + "type": "text" + }, + { + "bbox": [ + 164, + 438, + 218, + 450 + ], + "score": 0.93, + "content": "\\mathcal { E } _ { t } = \\mathcal { E } ( \\cdot , x _ { t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 438, + 505, + 451 + ], + "score": 1.0, + "content": ". The target times are defined by a set of time indices T. For forward", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 449, + 505, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 449, + 228, + 462 + ], + "score": 1.0, + "content": "prediction starting from input", + "type": "text" + }, + { + "bbox": [ + 229, + 451, + 258, + 461 + ], + "score": 0.9, + "content": "c = x _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 449, + 350, + 462 + ], + "score": 1.0, + "content": ", we may set targets to", + "type": "text" + }, + { + "bbox": [ + 350, + 449, + 409, + 461 + ], + "score": 0.93, + "content": "\\mathrm { T } = \\{ 1 , 2 , \\ldots \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 449, + 505, + 462 + ], + "score": 1.0, + "content": ". Fig 2 depicts this idea", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 460, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 505, + 474 + ], + "score": 1.0, + "content": "schematically. Intuitively, the penalty for a prediction is determined based on the closest matching", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "score": 1.0, + "content": "ground truth target frame. This loss incentivizes the model to latch on to “bottleneck” states in the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 482, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 505, + 495 + ], + "score": 1.0, + "content": "video, i.e., those with low uncertainty. In the bottle-tilting example, this would mean producing an", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 493, + 313, + 506 + ], + "spans": [ + { + "bbox": [ + 106, + 493, + 313, + 506 + ], + "score": 1.0, + "content": "image of the bottle after the water has come to rest.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 106, + 510, + 505, + 599 + ], + "lines": [ + { + "bbox": [ + 106, + 509, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 509, + 505, + 523 + ], + "score": 1.0, + "content": "One immediate concern with this minimum-over-time TAP loss might be that it could produce", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 521, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 106, + 521, + 369, + 533 + ], + "score": 1.0, + "content": "degenerate predictions very close to the input conditioning frames", + "type": "text" + }, + { + "bbox": [ + 369, + 523, + 375, + 531 + ], + "score": 0.53, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 375, + 521, + 505, + 533 + ], + "score": 1.0, + "content": ". However, as in the tilting bottle", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 532, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 532, + 506, + 545 + ], + "score": 1.0, + "content": "and other cases in Fig 1, uncertainty is not always lowest closest to the observed frames. Moreover,", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 543, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 106, + 543, + 188, + 555 + ], + "score": 1.0, + "content": "target frame indices", + "type": "text" + }, + { + "bbox": [ + 189, + 543, + 198, + 553 + ], + "score": 0.47, + "content": "\\mathrm { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 543, + 505, + 555 + ], + "score": 1.0, + "content": "are always disjoint from the input context frames, so the model’s prediction", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 554, + 505, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 505, + 566 + ], + "score": 1.0, + "content": "must be different from input frames by at least one step, which is no worse than the one-step-forward", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 565, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 505, + 577 + ], + "score": 1.0, + "content": "prediction of Eq 1. In our experiments, we show cases where the minimum-over-time loss above", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 576, + 505, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 505, + 589 + ], + "score": 1.0, + "content": "captures natural bottlenecks successfully. Further, Sec 3.2 shows how it is also possible to explicitly", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 587, + 271, + 600 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 261, + 600 + ], + "score": 1.0, + "content": "penalize predictions near input frames", + "type": "text" + }, + { + "bbox": [ + 261, + 589, + 267, + 597 + ], + "score": 0.41, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 267, + 587, + 271, + 600 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 41.5 + }, + { + "type": "text", + "bbox": [ + 106, + 603, + 505, + 659 + ], + "lines": [ + { + "bbox": [ + 105, + 603, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 392, + 617 + ], + "score": 1.0, + "content": "This minimum loss may be viewed as adaptively learning the time offset", + "type": "text" + }, + { + "bbox": [ + 392, + 606, + 398, + 614 + ], + "score": 0.77, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 603, + 506, + 617 + ], + "score": 1.0, + "content": ", but in fact, the predictor’s", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 614, + 506, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 506, + 627 + ], + "score": 1.0, + "content": "task is even simpler since it is not required to provide a timestamp accompanying its prediction. For", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 626, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 639 + ], + "score": 1.0, + "content": "example, in Fig 1(e), it need only specify which points in the maze the agent will go through; it need", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 636, + 506, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 506, + 650 + ], + "score": 1.0, + "content": "not specify when. Lifting the requirement of a timestamped prediction relieves TAP approaches of a", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 648, + 217, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 217, + 661 + ], + "score": 1.0, + "content": "significant implicit burden.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 48 + }, + { + "type": "text", + "bbox": [ + 106, + 667, + 504, + 690 + ], + "lines": [ + { + "bbox": [ + 105, + 666, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 681 + ], + "score": 1.0, + "content": "Recursive TAP. TAP models may also be trained for recursive prediction, by minimizing the", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 678, + 168, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 168, + 693 + ], + "score": 1.0, + "content": "following loss:", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 51.5 + }, + { + "type": "interline_equation", + "bbox": [ + 182, + 689, + 428, + 714 + ], + "lines": [ + { + "bbox": [ + 182, + 689, + 428, + 714 + ], + "spans": [ + { + "bbox": [ + 182, + 689, + 428, + 714 + ], + "score": 0.94, + "content": "G ^ { * } = \\underset { G } { \\arg \\operatorname* { m i n } } \\mathcal L _ { \\mathrm { r e c } } ( G ) = \\underset { G } { \\arg \\operatorname* { m i n } } \\sum _ { r } \\underset { t \\in \\mathrm { T } ( r ) } { \\min } \\mathcal { E } ( G ( c ( r ) ) , x _ { t } ) ,", + "type": "interline_equation", + "image_path": "d6c69cf1283c4a972c1f40ce26978427aaa9bcc2cf55c11ae034d55889795930.jpg" + } + ] + } + ], + "index": 53, + "virtual_lines": [ + { + "bbox": [ + 182, + 689, + 428, + 714 + ], + "spans": [], + "index": 53 + } + ] + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 118, + 721, + 455, + 732 + ], + "lines": [ + { + "bbox": [ + 119, + 719, + 457, + 734 + ], + "spans": [ + { + "bbox": [ + 119, + 719, + 457, + 734 + ], + "score": 1.0, + "content": "1We omit expectations over training samples throughout this paper to avoid notational clutter.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 106, + 81, + 415, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 79, + 416, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 79, + 416, + 96 + ], + "score": 1.0, + "content": "3 TIME-AGNOSTIC PREDICTION OF BOTTLENECK FRAMES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 106, + 102, + 506, + 159 + ], + "lines": [ + { + "bbox": [ + 106, + 103, + 505, + 115 + ], + "spans": [ + { + "bbox": [ + 106, + 103, + 505, + 115 + ], + "score": 1.0, + "content": "In visual prediction, the goal is to predict a set of unobserved target video frames given some observed", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 115, + 507, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 507, + 127 + ], + "score": 1.0, + "content": "context frames. In forward prediction, the context is the first frame, and the target is all future frames.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 126, + 505, + 137 + ], + "spans": [ + { + "bbox": [ + 106, + 126, + 505, + 137 + ], + "score": 1.0, + "content": "In the bidirectionally conditioned prediction case, the context is the first and the last frame, and the", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 135, + 506, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 135, + 506, + 150 + ], + "score": 1.0, + "content": "frames in between are the target. In Fig 1, we may wish to predict future images of the tilting bottle,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 147, + 395, + 160 + ], + "spans": [ + { + "bbox": [ + 106, + 147, + 395, + 160 + ], + "score": 1.0, + "content": "or intermediate images of an agent who traverses the maze successfully.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3, + "bbox_fs": [ + 105, + 103, + 507, + 160 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 171, + 255, + 183 + ], + "lines": [ + { + "bbox": [ + 106, + 171, + 256, + 184 + ], + "spans": [ + { + "bbox": [ + 106, + 171, + 256, + 184 + ], + "score": 1.0, + "content": "3.1 MINIMUM-OVER-TIME LOSS", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 190, + 298, + 289 + ], + "lines": [ + { + "bbox": [ + 106, + 190, + 298, + 202 + ], + "spans": [ + { + "bbox": [ + 106, + 190, + 298, + 202 + ], + "score": 1.0, + "content": "In standard fixed-time video prediction mod-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 201, + 298, + 213 + ], + "spans": [ + { + "bbox": [ + 106, + 201, + 298, + 213 + ], + "score": 1.0, + "content": "els (Ranzato et al., 2014; Oh et al., 2015; Math-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 212, + 298, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 212, + 298, + 223 + ], + "score": 1.0, + "content": "ieu et al., 2015; Vondrick et al., 2016a; Walker", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 223, + 298, + 235 + ], + "spans": [ + { + "bbox": [ + 105, + 223, + 298, + 235 + ], + "score": 1.0, + "content": "et al., 2016; Finn & Levine, 2017; Xue et al.,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 234, + 297, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 297, + 245 + ], + "score": 1.0, + "content": "2016; Oh et al., 2015; Ebert et al., 2017; Finn", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 245, + 299, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 299, + 257 + ], + "score": 1.0, + "content": "et al., 2016; Lee et al., 2018; Denton & Fergus,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 255, + 297, + 268 + ], + "spans": [ + { + "bbox": [ + 105, + 255, + 171, + 268 + ], + "score": 1.0, + "content": "2018), a frame", + "type": "text" + }, + { + "bbox": [ + 172, + 258, + 184, + 268 + ], + "score": 0.87, + "content": "x _ { \\tau }", + "type": "inline_equation" + }, + { + "bbox": [ + 184, + 255, + 275, + 268 + ], + "score": 1.0, + "content": "(video frame at time", + "type": "text" + }, + { + "bbox": [ + 275, + 258, + 282, + 267 + ], + "score": 0.63, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 283, + 255, + 297, + 268 + ], + "score": 1.0, + "content": ") is", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 267, + 297, + 279 + ], + "spans": [ + { + "bbox": [ + 106, + 267, + 297, + 279 + ], + "score": 1.0, + "content": "selected in advance to be the training target for", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 279, + 298, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 279, + 210, + 290 + ], + "score": 1.0, + "content": "some given input frames", + "type": "text" + }, + { + "bbox": [ + 211, + 281, + 217, + 288 + ], + "score": 0.59, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 279, + 298, + 290 + ], + "score": 1.0, + "content": ". For instance, in a", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 11, + "bbox_fs": [ + 105, + 190, + 299, + 290 + ] + }, + { + "type": "image", + "bbox": [ + 304, + 203, + 506, + 265 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 304, + 203, + 506, + 265 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 304, + 203, + 506, + 265 + ], + "spans": [ + { + "bbox": [ + 304, + 203, + 506, + 265 + ], + "score": 0.963, + "type": "image", + "image_path": "553b16ffacea6fe1931de7a05f2cd5a1dc88cc89a9ebb774a469ea6e63d25d18.jpg" + } + ] + } + ], + "index": 17.5, + "virtual_lines": [ + { + "bbox": [ + 304, + 203, + 506, + 218.5 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 304, + 218.5, + 506, + 234.0 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 304, + 234.0, + 506, + 249.5 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 304, + 249.5, + 506, + 265.0 + ], + "spans": [], + "index": 19 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 324, + 272, + 485, + 284 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 322, + 272, + 486, + 284 + ], + "spans": [ + { + "bbox": [ + 322, + 272, + 486, + 284 + ], + "score": 1.0, + "content": "Figure 2: The TAP minimum-over time loss.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + } + ], + "index": 18.75 + }, + { + "type": "text", + "bbox": [ + 106, + 290, + 503, + 312 + ], + "lines": [ + { + "bbox": [ + 105, + 288, + 503, + 304 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 302, + 304 + ], + "score": 1.0, + "content": "typical forward prediction setup, the input may be", + "type": "text" + }, + { + "bbox": [ + 302, + 291, + 331, + 300 + ], + "score": 0.88, + "content": "c = x _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 288, + 467, + 304 + ], + "score": 1.0, + "content": ", and the target frame may be set to", + "type": "text" + }, + { + "bbox": [ + 468, + 292, + 503, + 300 + ], + "score": 0.89, + "content": "x _ { \\tau } = x _ { 1 }", + "type": "inline_equation" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 299, + 492, + 314 + ], + "spans": [ + { + "bbox": [ + 105, + 299, + 154, + 314 + ], + "score": 1.0, + "content": "A predictor", + "type": "text" + }, + { + "bbox": [ + 155, + 301, + 164, + 310 + ], + "score": 0.83, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 299, + 249, + 314 + ], + "score": 1.0, + "content": "takes context frames", + "type": "text" + }, + { + "bbox": [ + 249, + 303, + 255, + 310 + ], + "score": 0.69, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 299, + 403, + 314 + ], + "score": 1.0, + "content": "as input and produces a single frame", + "type": "text" + }, + { + "bbox": [ + 404, + 300, + 424, + 312 + ], + "score": 0.87, + "content": "G ( c )", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 299, + 429, + 314 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 429, + 301, + 438, + 310 + ], + "score": 0.72, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 299, + 492, + 314 + ], + "score": 1.0, + "content": "is trained as:", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 288, + 503, + 314 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 211, + 313, + 398, + 333 + ], + "lines": [ + { + "bbox": [ + 211, + 313, + 398, + 333 + ], + "spans": [ + { + "bbox": [ + 211, + 313, + 398, + 333 + ], + "score": 0.92, + "content": "G ^ { * } = \\underset { G } { \\arg \\operatorname* { m i n } } \\mathcal { L } _ { 0 } ( G ) = \\underset { G } { \\arg \\operatorname* { m i n } } \\mathcal { E } ( G ( c ) , x _ { \\tau } ) ,", + "type": "interline_equation", + "image_path": "7abefb258e6867e561fc04bab08fbf27c1ebcdb5a6e54c199e2e4aa67b5643ae.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 211, + 313, + 398, + 333 + ], + "spans": [], + "index": 23 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 334, + 505, + 357 + ], + "lines": [ + { + "bbox": [ + 105, + 332, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 133, + 347 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 335, + 141, + 344 + ], + "score": 0.8, + "content": "\\mathcal { E }", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 332, + 311, + 347 + ], + "score": 1.0, + "content": "is a measure of prediction error, such as", + "type": "text" + }, + { + "bbox": [ + 311, + 334, + 369, + 345 + ], + "score": 0.87, + "content": "\\| G ( c ) - x _ { \\tau } \\| _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 332, + 505, + 347 + ], + "score": 1.0, + "content": ".1 This predictor may be applied", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 345, + 466, + 358 + ], + "spans": [ + { + "bbox": [ + 106, + 345, + 326, + 358 + ], + "score": 1.0, + "content": "recursively at test time to generate more predictions as", + "type": "text" + }, + { + "bbox": [ + 326, + 345, + 418, + 357 + ], + "score": 0.81, + "content": "{ \\dot { G } } ( G ( c ) ) , G ( G ( G ( c ) ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 345, + 466, + 358 + ], + "score": 1.0, + "content": ", and so on.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5, + "bbox_fs": [ + 105, + 332, + 505, + 358 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 361, + 505, + 406 + ], + "lines": [ + { + "bbox": [ + 105, + 362, + 506, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 506, + 375 + ], + "score": 1.0, + "content": "We propose to depart from this fixed-time paradigm by decoupling prediction from a rigid notion of", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 372, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 357, + 385 + ], + "score": 1.0, + "content": "time. Instead of predicting the video frame at a specified time", + "type": "text" + }, + { + "bbox": [ + 357, + 375, + 364, + 383 + ], + "score": 0.76, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 372, + 505, + 385 + ], + "score": 1.0, + "content": ", we propose to predict predictable", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 384, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 505, + 397 + ], + "score": 1.0, + "content": "bottleneck video frames through a time-agnostic predictor (TAP), as motivated in Sec 1. To train this", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 395, + 370, + 407 + ], + "spans": [ + { + "bbox": [ + 106, + 395, + 370, + 407 + ], + "score": 1.0, + "content": "predictor, we minimize the following “minimum-over-time” loss:", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 362, + 506, + 407 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 205, + 408, + 405, + 428 + ], + "lines": [ + { + "bbox": [ + 205, + 408, + 405, + 428 + ], + "spans": [ + { + "bbox": [ + 205, + 408, + 405, + 428 + ], + "score": 0.91, + "content": "G ^ { * } = \\underset { G } { \\arg \\operatorname* { m i n } } \\ : \\mathcal { L } ( G ) = \\underset { G } { \\arg \\operatorname* { m i n } } \\ : \\underset { t \\in \\mathrm { T } } { \\operatorname* { m i n } } \\ : \\mathcal { E } ( G ( c ) , x _ { t } ) ,", + "type": "interline_equation", + "image_path": "d13da1952f7635b0f6b8307cee21cbf2e9fcb49b6c92bea2025ccd8338a670b8.jpg" + } + ] + } + ], + "index": 30, + "virtual_lines": [ + { + "bbox": [ + 205, + 408, + 405, + 428 + ], + "spans": [], + "index": 30 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 428, + 505, + 505 + ], + "lines": [ + { + "bbox": [ + 105, + 427, + 506, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 231, + 439 + ], + "score": 1.0, + "content": "where the key difference from", + "type": "text" + }, + { + "bbox": [ + 232, + 428, + 252, + 439 + ], + "score": 0.26, + "content": "\\mathrm { E q ~ } 1", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 427, + 506, + 439 + ], + "score": 1.0, + "content": "is that the loss is now a minimum over target times of a time-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 438, + 505, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 438, + 164, + 451 + ], + "score": 1.0, + "content": "indexed error", + "type": "text" + }, + { + "bbox": [ + 164, + 438, + 218, + 450 + ], + "score": 0.93, + "content": "\\mathcal { E } _ { t } = \\mathcal { E } ( \\cdot , x _ { t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 438, + 505, + 451 + ], + "score": 1.0, + "content": ". The target times are defined by a set of time indices T. For forward", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 449, + 505, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 449, + 228, + 462 + ], + "score": 1.0, + "content": "prediction starting from input", + "type": "text" + }, + { + "bbox": [ + 229, + 451, + 258, + 461 + ], + "score": 0.9, + "content": "c = x _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 449, + 350, + 462 + ], + "score": 1.0, + "content": ", we may set targets to", + "type": "text" + }, + { + "bbox": [ + 350, + 449, + 409, + 461 + ], + "score": 0.93, + "content": "\\mathrm { T } = \\{ 1 , 2 , \\ldots \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 449, + 505, + 462 + ], + "score": 1.0, + "content": ". Fig 2 depicts this idea", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 460, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 505, + 474 + ], + "score": 1.0, + "content": "schematically. Intuitively, the penalty for a prediction is determined based on the closest matching", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "score": 1.0, + "content": "ground truth target frame. This loss incentivizes the model to latch on to “bottleneck” states in the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 482, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 505, + 495 + ], + "score": 1.0, + "content": "video, i.e., those with low uncertainty. In the bottle-tilting example, this would mean producing an", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 493, + 313, + 506 + ], + "spans": [ + { + "bbox": [ + 106, + 493, + 313, + 506 + ], + "score": 1.0, + "content": "image of the bottle after the water has come to rest.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 34, + "bbox_fs": [ + 105, + 427, + 506, + 506 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 510, + 505, + 599 + ], + "lines": [ + { + "bbox": [ + 106, + 509, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 509, + 505, + 523 + ], + "score": 1.0, + "content": "One immediate concern with this minimum-over-time TAP loss might be that it could produce", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 521, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 106, + 521, + 369, + 533 + ], + "score": 1.0, + "content": "degenerate predictions very close to the input conditioning frames", + "type": "text" + }, + { + "bbox": [ + 369, + 523, + 375, + 531 + ], + "score": 0.53, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 375, + 521, + 505, + 533 + ], + "score": 1.0, + "content": ". However, as in the tilting bottle", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 532, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 532, + 506, + 545 + ], + "score": 1.0, + "content": "and other cases in Fig 1, uncertainty is not always lowest closest to the observed frames. Moreover,", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 543, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 106, + 543, + 188, + 555 + ], + "score": 1.0, + "content": "target frame indices", + "type": "text" + }, + { + "bbox": [ + 189, + 543, + 198, + 553 + ], + "score": 0.47, + "content": "\\mathrm { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 543, + 505, + 555 + ], + "score": 1.0, + "content": "are always disjoint from the input context frames, so the model’s prediction", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 554, + 505, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 505, + 566 + ], + "score": 1.0, + "content": "must be different from input frames by at least one step, which is no worse than the one-step-forward", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 565, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 505, + 577 + ], + "score": 1.0, + "content": "prediction of Eq 1. In our experiments, we show cases where the minimum-over-time loss above", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 576, + 505, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 505, + 589 + ], + "score": 1.0, + "content": "captures natural bottlenecks successfully. Further, Sec 3.2 shows how it is also possible to explicitly", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 587, + 271, + 600 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 261, + 600 + ], + "score": 1.0, + "content": "penalize predictions near input frames", + "type": "text" + }, + { + "bbox": [ + 261, + 589, + 267, + 597 + ], + "score": 0.41, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 267, + 587, + 271, + 600 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 41.5, + "bbox_fs": [ + 105, + 509, + 506, + 600 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 603, + 505, + 659 + ], + "lines": [ + { + "bbox": [ + 105, + 603, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 392, + 617 + ], + "score": 1.0, + "content": "This minimum loss may be viewed as adaptively learning the time offset", + "type": "text" + }, + { + "bbox": [ + 392, + 606, + 398, + 614 + ], + "score": 0.77, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 603, + 506, + 617 + ], + "score": 1.0, + "content": ", but in fact, the predictor’s", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 614, + 506, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 506, + 627 + ], + "score": 1.0, + "content": "task is even simpler since it is not required to provide a timestamp accompanying its prediction. For", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 626, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 639 + ], + "score": 1.0, + "content": "example, in Fig 1(e), it need only specify which points in the maze the agent will go through; it need", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 636, + 506, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 506, + 650 + ], + "score": 1.0, + "content": "not specify when. Lifting the requirement of a timestamped prediction relieves TAP approaches of a", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 648, + 217, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 217, + 661 + ], + "score": 1.0, + "content": "significant implicit burden.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 48, + "bbox_fs": [ + 105, + 603, + 506, + 661 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 667, + 504, + 690 + ], + "lines": [ + { + "bbox": [ + 105, + 666, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 681 + ], + "score": 1.0, + "content": "Recursive TAP. TAP models may also be trained for recursive prediction, by minimizing the", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 678, + 168, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 168, + 693 + ], + "score": 1.0, + "content": "following loss:", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 51.5, + "bbox_fs": [ + 105, + 666, + 505, + 693 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 182, + 689, + 428, + 714 + ], + "lines": [ + { + "bbox": [ + 182, + 689, + 428, + 714 + ], + "spans": [ + { + "bbox": [ + 182, + 689, + 428, + 714 + ], + "score": 0.94, + "content": "G ^ { * } = \\underset { G } { \\arg \\operatorname* { m i n } } \\mathcal L _ { \\mathrm { r e c } } ( G ) = \\underset { G } { \\arg \\operatorname* { m i n } } \\sum _ { r } \\underset { t \\in \\mathrm { T } ( r ) } { \\min } \\mathcal { E } ( G ( c ( r ) ) , x _ { t } ) ,", + "type": "interline_equation", + "image_path": "d6c69cf1283c4a972c1f40ce26978427aaa9bcc2cf55c11ae034d55889795930.jpg" + } + ] + } + ], + "index": 53, + "virtual_lines": [ + { + "bbox": [ + 182, + 689, + 428, + 714 + ], + "spans": [], + "index": 53 + } + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 149 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 132, + 95 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 82, + 150, + 95 + ], + "score": 0.91, + "content": "c ( r )", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 82, + 168, + 95 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 169, + 82, + 189, + 95 + ], + "score": 0.89, + "content": "\\mathrm { T } ( r )", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 82, + 366, + 95 + ], + "score": 1.0, + "content": "are the input and target set at recursion level", + "type": "text" + }, + { + "bbox": [ + 367, + 85, + 372, + 93 + ], + "score": 0.72, + "content": "r", + "type": "inline_equation" + }, + { + "bbox": [ + 373, + 82, + 505, + 95 + ], + "score": 1.0, + "content": ", both dynamically adapted based", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 255, + 106 + ], + "score": 1.0, + "content": "on the previous prediction. The input", + "type": "text" + }, + { + "bbox": [ + 255, + 93, + 273, + 105 + ], + "score": 0.88, + "content": "c ( r )", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 93, + 422, + 106 + ], + "score": 1.0, + "content": "may be set to the previous prediction", + "type": "text" + }, + { + "bbox": [ + 423, + 93, + 472, + 106 + ], + "score": 0.95, + "content": "G ( c ( r - 1 ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 472, + 93, + 506, + 106 + ], + "score": 1.0, + "content": ", so that", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 103, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 103, + 225, + 118 + ], + "score": 1.0, + "content": "the sequence of predictions is", + "type": "text" + }, + { + "bbox": [ + 225, + 105, + 335, + 117 + ], + "score": 0.87, + "content": "( G ( c ( 0 ) ) , G ( G ( c ( 0 ) ) ) , \\dots )", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 103, + 339, + 118 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 339, + 105, + 360, + 116 + ], + "score": 0.76, + "content": "\\mathrm { T } ( r )", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 103, + 506, + 118 + ], + "score": 1.0, + "content": "is set to target all times after the last", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 295, + 127 + ], + "score": 1.0, + "content": "prediction. In other words, if the prediction at", + "type": "text" + }, + { + "bbox": [ + 295, + 117, + 320, + 126 + ], + "score": 0.87, + "content": "r = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 115, + 406, + 127 + ], + "score": 1.0, + "content": "was closest to frame", + "type": "text" + }, + { + "bbox": [ + 406, + 117, + 417, + 127 + ], + "score": 0.86, + "content": "x _ { 5 }", + "type": "inline_equation" + }, + { + "bbox": [ + 418, + 115, + 480, + 127 + ], + "score": 1.0, + "content": ", the targets for", + "type": "text" + }, + { + "bbox": [ + 480, + 116, + 505, + 126 + ], + "score": 0.89, + "content": "r = 1", + "type": "inline_equation" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 144, + 139 + ], + "score": 1.0, + "content": "are set to", + "type": "text" + }, + { + "bbox": [ + 145, + 126, + 216, + 138 + ], + "score": 0.93, + "content": "\\mathrm { T } ( 1 ) = \\{ 6 , 7 , \\ldots \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 126, + 505, + 139 + ], + "score": 1.0, + "content": ". While we also test recursive TAP in Sec 4, in the rest of this section, we", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 136, + 391, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 136, + 309, + 150 + ], + "score": 1.0, + "content": "discuss the non-recursive formulation, building on", + "type": "text" + }, + { + "bbox": [ + 309, + 138, + 329, + 149 + ], + "score": 0.4, + "content": "\\operatorname { E q } 2", + "type": "inline_equation" + }, + { + "bbox": [ + 329, + 136, + 391, + 150 + ], + "score": 1.0, + "content": ", for simplicity.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 106, + 157, + 506, + 226 + ], + "lines": [ + { + "bbox": [ + 105, + 156, + 507, + 170 + ], + "spans": [ + { + "bbox": [ + 105, + 156, + 507, + 170 + ], + "score": 1.0, + "content": "Bidirectional TAP. Finally, while the above description of TAP has focused on forward prediction,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 167, + 507, + 183 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 446, + 183 + ], + "score": 1.0, + "content": "the TAP loss of Eq 2 easily generalizes to bidirectional prediction. Given input frames", + "type": "text" + }, + { + "bbox": [ + 446, + 169, + 502, + 181 + ], + "score": 0.91, + "content": "c = ( x _ { 0 } , x _ { \\mathrm { l a s t } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 167, + 507, + 183 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 178, + 507, + 193 + ], + "spans": [ + { + "bbox": [ + 105, + 178, + 386, + 193 + ], + "score": 1.0, + "content": "fixed-time bidirectional predictors might target, say, the middle frame", + "type": "text" + }, + { + "bbox": [ + 386, + 182, + 435, + 192 + ], + "score": 0.9, + "content": "x _ { \\tau } = x _ { \\mathrm { l a s t / 2 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 435, + 178, + 507, + 193 + ], + "score": 1.0, + "content": ". Instead, bidirec-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 192, + 506, + 205 + ], + "spans": [ + { + "bbox": [ + 106, + 192, + 318, + 205 + ], + "score": 1.0, + "content": "tional TAP models target all intermediate frames, i.e.,", + "type": "text" + }, + { + "bbox": [ + 319, + 192, + 413, + 204 + ], + "score": 0.91, + "content": "\\mathrm { T } = \\{ 1 , 2 , . . . , \\mathrm { l a s t } - 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 413, + 192, + 506, + 205 + ], + "score": 1.0, + "content": "in Eq 2. As in forward", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 202, + 507, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 507, + 216 + ], + "score": 1.0, + "content": "prediction, the model has incentive to predict predictable frames. In the maze example from Fig 1,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 213, + 397, + 226 + ], + "spans": [ + { + "bbox": [ + 106, + 213, + 397, + 226 + ], + "score": 1.0, + "content": "this would mean producing an image of the agent at one of the asterisks.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8.5 + }, + { + "type": "title", + "bbox": [ + 106, + 239, + 375, + 251 + ], + "lines": [ + { + "bbox": [ + 106, + 239, + 376, + 252 + ], + "spans": [ + { + "bbox": [ + 106, + 239, + 376, + 252 + ], + "score": 1.0, + "content": "3.2 FROM MINIMUM TO GENERALIZED MINIMUM TAP LOSS", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 259, + 504, + 294 + ], + "lines": [ + { + "bbox": [ + 105, + 259, + 506, + 273 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 506, + 273 + ], + "score": 1.0, + "content": "Within the time-agnostic prediction paradigm, we may still want to specify preferences for some", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 271, + 506, + 284 + ], + "spans": [ + { + "bbox": [ + 106, + 271, + 506, + 284 + ], + "score": 1.0, + "content": "times over others, or for some visual properties of the predictions. Consider the minimum-over-time", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 282, + 383, + 294 + ], + "spans": [ + { + "bbox": [ + 106, + 282, + 124, + 294 + ], + "score": 1.0, + "content": "loss", + "type": "text" + }, + { + "bbox": [ + 125, + 282, + 133, + 292 + ], + "score": 0.8, + "content": "\\mathcal { L }", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 282, + 383, + 294 + ], + "score": 1.0, + "content": "in Eq 2. Taking the minimum inside, this may be rewritten as:", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14 + }, + { + "type": "interline_equation", + "bbox": [ + 237, + 302, + 372, + 321 + ], + "lines": [ + { + "bbox": [ + 237, + 302, + 372, + 321 + ], + "spans": [ + { + "bbox": [ + 237, + 302, + 372, + 321 + ], + "score": 0.93, + "content": "{ \\mathcal { L } } ( G ) = \\operatorname* { m i n } _ { t \\in T } { \\mathcal { E } } _ { t } = { \\mathcal { E } } _ { \\arg \\operatorname* { m i n } _ { t \\in T } { \\mathcal { E } } _ { t } } ,", + "type": "interline_equation", + "image_path": "8e2a838c3ebaff04bc9293bfbab18097ea7233e60e1c1c740e279db5c771141d.jpg" + } + ] + } + ], + "index": 16, + "virtual_lines": [ + { + "bbox": [ + 237, + 302, + 372, + 321 + ], + "spans": [], + "index": 16 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 330, + 504, + 353 + ], + "lines": [ + { + "bbox": [ + 106, + 330, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 330, + 258, + 343 + ], + "score": 1.0, + "content": "where we use the time-indexed error", + "type": "text" + }, + { + "bbox": [ + 259, + 331, + 268, + 342 + ], + "score": 0.88, + "content": "\\mathcal { E } _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 330, + 339, + 343 + ], + "score": 1.0, + "content": "as shorthand for", + "type": "text" + }, + { + "bbox": [ + 339, + 331, + 370, + 343 + ], + "score": 0.92, + "content": "\\mathcal { E } ( . , x _ { t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 330, + 505, + 343 + ], + "score": 1.0, + "content": ". We may now extend this to the", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 341, + 457, + 354 + ], + "spans": [ + { + "bbox": [ + 106, + 341, + 457, + 354 + ], + "score": 1.0, + "content": "following “generalized minimum” loss, where the outer and inner errors are decoupled:", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "interline_equation", + "bbox": [ + 256, + 361, + 354, + 378 + ], + "lines": [ + { + "bbox": [ + 256, + 361, + 354, + 378 + ], + "spans": [ + { + "bbox": [ + 256, + 361, + 354, + 378 + ], + "score": 0.92, + "content": "\\begin{array} { r } { \\mathcal { L } ^ { \\prime } ( G ) = \\mathcal { E } _ { \\mathrm { a r g m i n } _ { t \\in T } } \\mathcal { E } _ { t } ^ { \\prime } . } \\end{array}", + "type": "interline_equation", + "image_path": "499b1782e84de4fe899e511693d3a4ad924364cd3e84c6f7b59c9a41ff9e5202.jpg" + } + ] + } + ], + "index": 19, + "virtual_lines": [ + { + "bbox": [ + 256, + 361, + 354, + 378 + ], + "spans": [], + "index": 19 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 386, + 505, + 464 + ], + "lines": [ + { + "bbox": [ + 105, + 385, + 506, + 400 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 131, + 400 + ], + "score": 1.0, + "content": "Now,", + "type": "text" + }, + { + "bbox": [ + 131, + 387, + 141, + 398 + ], + "score": 0.88, + "content": "\\mathcal { E } _ { t } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 385, + 506, + 400 + ], + "score": 1.0, + "content": ", over which the minimum is computed, could be designed to express preferences about", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 398, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 286, + 410 + ], + "score": 1.0, + "content": "which frames to predict. In the simplest case,", + "type": "text" + }, + { + "bbox": [ + 286, + 398, + 319, + 410 + ], + "score": 0.93, + "content": "\\mathcal { E } _ { t } ^ { \\prime } = \\mathcal { E } _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 319, + 398, + 414, + 410 + ], + "score": 1.0, + "content": ", and the loss reduces to", + "type": "text" + }, + { + "bbox": [ + 414, + 398, + 434, + 409 + ], + "score": 0.42, + "content": "\\operatorname { E q } 2", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 398, + 505, + 410 + ], + "score": 1.0, + "content": ". Instead, suppose", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 408, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 344, + 421 + ], + "score": 1.0, + "content": "that predictions at some times are preferred over others. Let", + "type": "text" + }, + { + "bbox": [ + 344, + 409, + 364, + 421 + ], + "score": 0.92, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 408, + 506, + 421 + ], + "score": 1.0, + "content": "express the preference value for all", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 419, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 156, + 433 + ], + "score": 1.0, + "content": "target times", + "type": "text" + }, + { + "bbox": [ + 156, + 420, + 180, + 430 + ], + "score": 0.89, + "content": "t \\in T", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 419, + 241, + 433 + ], + "score": 1.0, + "content": ", so that higher", + "type": "text" + }, + { + "bbox": [ + 242, + 420, + 261, + 432 + ], + "score": 0.91, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 419, + 449, + 433 + ], + "score": 1.0, + "content": "indicates higher preference. Then we may set", + "type": "text" + }, + { + "bbox": [ + 450, + 420, + 505, + 432 + ], + "score": 0.91, + "content": "\\mathcal { E } _ { t } ^ { \\prime } = \\mathcal { E } _ { t } / w ( t )", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 430, + 506, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 161, + 443 + ], + "score": 1.0, + "content": "so that times", + "type": "text" + }, + { + "bbox": [ + 162, + 432, + 167, + 441 + ], + "score": 0.72, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 430, + 218, + 443 + ], + "score": 1.0, + "content": "with higher", + "type": "text" + }, + { + "bbox": [ + 218, + 431, + 238, + 442 + ], + "score": 0.91, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 238, + 430, + 473, + 443 + ], + "score": 1.0, + "content": "are preferred in the arg min. In our experiments, we set", + "type": "text" + }, + { + "bbox": [ + 473, + 432, + 493, + 443 + ], + "score": 0.9, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 493, + 430, + 506, + 443 + ], + "score": 1.0, + "content": "to", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 441, + 506, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 506, + 454 + ], + "score": 1.0, + "content": "linearly increase with time during forward prediction and to a truncated discrete Gaussian centered at", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 452, + 268, + 465 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 268, + 465 + ], + "score": 1.0, + "content": "the midpoint in bidirectional prediction.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 106, + 469, + 505, + 536 + ], + "lines": [ + { + "bbox": [ + 106, + 470, + 505, + 481 + ], + "spans": [ + { + "bbox": [ + 106, + 470, + 505, + 481 + ], + "score": 1.0, + "content": "At this point, one might ask: could we not directly incorporate preferences into the outer error?", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 480, + 506, + 493 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 271, + 493 + ], + "score": 1.0, + "content": "For instance, why not simply optimize", + "type": "text" + }, + { + "bbox": [ + 272, + 480, + 329, + 492 + ], + "score": 0.92, + "content": "\\mathrm { m i n } _ { t } \\mathcal { E } _ { t } / w ( t ) ^ { \\star }", + "type": "inline_equation" + }, + { + "bbox": [ + 329, + 480, + 506, + 493 + ], + "score": 1.0, + "content": "? Unfortunately, that would have the side-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 491, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 106, + 491, + 453, + 504 + ], + "score": 1.0, + "content": "effect of downweighting the errors computed against frames with higher preferences", + "type": "text" + }, + { + "bbox": [ + 453, + 491, + 473, + 504 + ], + "score": 0.91, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 474, + 491, + 505, + 504 + ], + "score": 1.0, + "content": ", which", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 501, + 506, + 516 + ], + "spans": [ + { + "bbox": [ + 104, + 501, + 412, + 516 + ], + "score": 1.0, + "content": "is counterproductive. Decoupling the outer and inner errors instead, as in", + "type": "text" + }, + { + "bbox": [ + 412, + 502, + 433, + 514 + ], + "score": 0.36, + "content": "\\operatorname { E q } 5", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 501, + 506, + 516 + ], + "score": 1.0, + "content": ", allows applying", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 513, + 506, + 526 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 154, + 526 + ], + "score": 1.0, + "content": "preferences", + "type": "text" + }, + { + "bbox": [ + 154, + 513, + 174, + 525 + ], + "score": 0.91, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 513, + 506, + 526 + ], + "score": 1.0, + "content": "only to select the target frame to compute the outer loss against; the outer loss itself", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 524, + 407, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 524, + 407, + 536 + ], + "score": 1.0, + "content": "penalizes prediction errors equally regardless of which frame was selected.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 107, + 541, + 505, + 586 + ], + "lines": [ + { + "bbox": [ + 106, + 541, + 505, + 553 + ], + "spans": [ + { + "bbox": [ + 106, + 541, + 505, + 553 + ], + "score": 1.0, + "content": "The generalized minimum formulation may be used to express other kinds of preferences too. For", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 553, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 553, + 505, + 565 + ], + "score": 1.0, + "content": "instance, when using predictions as subgoals in a planner, perhaps some states are more expensive to", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 564, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 505, + 576 + ], + "score": 1.0, + "content": "reach than others. We also use the generalized minimum to select frames using different criteria than", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 574, + 339, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 339, + 586 + ], + "score": 1.0, + "content": "the prediction penalty itself, as we will discuss in Sec 3.5.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34.5 + }, + { + "type": "title", + "bbox": [ + 108, + 599, + 298, + 611 + ], + "lines": [ + { + "bbox": [ + 105, + 598, + 299, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 299, + 613 + ], + "score": 1.0, + "content": "3.3 TIME-AGNOSTIC CONDITIONAL GANS", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 619, + 505, + 686 + ], + "lines": [ + { + "bbox": [ + 105, + 619, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 281, + 632 + ], + "score": 1.0, + "content": "TAP is not limited to simple losses such as", + "type": "text" + }, + { + "bbox": [ + 282, + 620, + 292, + 631 + ], + "score": 0.88, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 292, + 619, + 304, + 632 + ], + "score": 1.0, + "content": "or", + "type": "text" + }, + { + "bbox": [ + 304, + 620, + 314, + 631 + ], + "score": 0.88, + "content": "\\ell _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 619, + 506, + 632 + ], + "score": 1.0, + "content": "errors; it can be extended to handle expressive", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 631, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 106, + 631, + 505, + 644 + ], + "score": 1.0, + "content": "GAN losses to improve perceptual quality. A standard conditional GAN (CGAN) in fixed-time", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 641, + 506, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 236, + 654 + ], + "score": 1.0, + "content": "video prediction targeting time", + "type": "text" + }, + { + "bbox": [ + 236, + 644, + 243, + 651 + ], + "score": 0.77, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 244, + 641, + 420, + 654 + ], + "score": 1.0, + "content": "works as follows: given a “discriminator”", + "type": "text" + }, + { + "bbox": [ + 420, + 642, + 430, + 651 + ], + "score": 0.82, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 430, + 641, + 506, + 654 + ], + "score": 1.0, + "content": "that outputs 0 for", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 653, + 505, + 665 + ], + "spans": [ + { + "bbox": [ + 106, + 653, + 408, + 665 + ], + "score": 1.0, + "content": "input-prediction tuples and 1 for input-ground truth tuples, the generator", + "type": "text" + }, + { + "bbox": [ + 408, + 653, + 417, + 663 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 653, + 505, + 665 + ], + "score": 1.0, + "content": "is trained to fool the", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 663, + 507, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 507, + 676 + ], + "score": 1.0, + "content": "discriminator. The discriminator in turn is trained adversarially using a binary cross-entropy loss.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 675, + 247, + 687 + ], + "spans": [ + { + "bbox": [ + 106, + 675, + 247, + 687 + ], + "score": 1.0, + "content": "The CGAN objective is written as:", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 40.5 + }, + { + "type": "interline_equation", + "bbox": [ + 198, + 694, + 412, + 732 + ], + "lines": [ + { + "bbox": [ + 198, + 694, + 412, + 732 + ], + "spans": [ + { + "bbox": [ + 198, + 694, + 412, + 732 + ], + "score": 0.9, + "content": "\\begin{array} { r l } & { G ^ { * } = \\underset { G } { \\arg \\operatorname* { m i n } } \\ \\underset { D } { \\operatorname* { m a x } } \\mathcal { L } _ { \\mathrm { c g a n } } ( G , D ) , } \\\\ & { } \\\\ & { \\mathcal { L } _ { \\mathrm { c g a n } } ( G , D ) = \\log ( D ( c , x _ { \\tau } ) ) + \\log ( 1 - D ( c , G ( c ) ) } \\end{array}", + "type": "interline_equation", + "image_path": "a344bd70cbb79bd7a16342e2a26baaad21507932570028252c1ff0aaf86ac95f.jpg" + } + ] + } + ], + "index": 44.5, + "virtual_lines": [ + { + "bbox": [ + 198, + 694, + 412, + 713.0 + ], + "spans": [], + "index": 44 + }, + { + "bbox": [ + 198, + 713.0, + 412, + 732.0 + ], + "spans": [], + "index": 45 + } + ] + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 759 + ], + "lines": [] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 149 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 132, + 95 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 82, + 150, + 95 + ], + "score": 0.91, + "content": "c ( r )", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 82, + 168, + 95 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 169, + 82, + 189, + 95 + ], + "score": 0.89, + "content": "\\mathrm { T } ( r )", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 82, + 366, + 95 + ], + "score": 1.0, + "content": "are the input and target set at recursion level", + "type": "text" + }, + { + "bbox": [ + 367, + 85, + 372, + 93 + ], + "score": 0.72, + "content": "r", + "type": "inline_equation" + }, + { + "bbox": [ + 373, + 82, + 505, + 95 + ], + "score": 1.0, + "content": ", both dynamically adapted based", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 255, + 106 + ], + "score": 1.0, + "content": "on the previous prediction. The input", + "type": "text" + }, + { + "bbox": [ + 255, + 93, + 273, + 105 + ], + "score": 0.88, + "content": "c ( r )", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 93, + 422, + 106 + ], + "score": 1.0, + "content": "may be set to the previous prediction", + "type": "text" + }, + { + "bbox": [ + 423, + 93, + 472, + 106 + ], + "score": 0.95, + "content": "G ( c ( r - 1 ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 472, + 93, + 506, + 106 + ], + "score": 1.0, + "content": ", so that", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 103, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 103, + 225, + 118 + ], + "score": 1.0, + "content": "the sequence of predictions is", + "type": "text" + }, + { + "bbox": [ + 225, + 105, + 335, + 117 + ], + "score": 0.87, + "content": "( G ( c ( 0 ) ) , G ( G ( c ( 0 ) ) ) , \\dots )", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 103, + 339, + 118 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 339, + 105, + 360, + 116 + ], + "score": 0.76, + "content": "\\mathrm { T } ( r )", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 103, + 506, + 118 + ], + "score": 1.0, + "content": "is set to target all times after the last", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 295, + 127 + ], + "score": 1.0, + "content": "prediction. In other words, if the prediction at", + "type": "text" + }, + { + "bbox": [ + 295, + 117, + 320, + 126 + ], + "score": 0.87, + "content": "r = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 115, + 406, + 127 + ], + "score": 1.0, + "content": "was closest to frame", + "type": "text" + }, + { + "bbox": [ + 406, + 117, + 417, + 127 + ], + "score": 0.86, + "content": "x _ { 5 }", + "type": "inline_equation" + }, + { + "bbox": [ + 418, + 115, + 480, + 127 + ], + "score": 1.0, + "content": ", the targets for", + "type": "text" + }, + { + "bbox": [ + 480, + 116, + 505, + 126 + ], + "score": 0.89, + "content": "r = 1", + "type": "inline_equation" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 144, + 139 + ], + "score": 1.0, + "content": "are set to", + "type": "text" + }, + { + "bbox": [ + 145, + 126, + 216, + 138 + ], + "score": 0.93, + "content": "\\mathrm { T } ( 1 ) = \\{ 6 , 7 , \\ldots \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 126, + 505, + 139 + ], + "score": 1.0, + "content": ". While we also test recursive TAP in Sec 4, in the rest of this section, we", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 136, + 391, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 136, + 309, + 150 + ], + "score": 1.0, + "content": "discuss the non-recursive formulation, building on", + "type": "text" + }, + { + "bbox": [ + 309, + 138, + 329, + 149 + ], + "score": 0.4, + "content": "\\operatorname { E q } 2", + "type": "inline_equation" + }, + { + "bbox": [ + 329, + 136, + 391, + 150 + ], + "score": 1.0, + "content": ", for simplicity.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5, + "bbox_fs": [ + 105, + 82, + 506, + 150 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 157, + 506, + 226 + ], + "lines": [ + { + "bbox": [ + 105, + 156, + 507, + 170 + ], + "spans": [ + { + "bbox": [ + 105, + 156, + 507, + 170 + ], + "score": 1.0, + "content": "Bidirectional TAP. Finally, while the above description of TAP has focused on forward prediction,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 167, + 507, + 183 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 446, + 183 + ], + "score": 1.0, + "content": "the TAP loss of Eq 2 easily generalizes to bidirectional prediction. Given input frames", + "type": "text" + }, + { + "bbox": [ + 446, + 169, + 502, + 181 + ], + "score": 0.91, + "content": "c = ( x _ { 0 } , x _ { \\mathrm { l a s t } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 167, + 507, + 183 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 178, + 507, + 193 + ], + "spans": [ + { + "bbox": [ + 105, + 178, + 386, + 193 + ], + "score": 1.0, + "content": "fixed-time bidirectional predictors might target, say, the middle frame", + "type": "text" + }, + { + "bbox": [ + 386, + 182, + 435, + 192 + ], + "score": 0.9, + "content": "x _ { \\tau } = x _ { \\mathrm { l a s t / 2 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 435, + 178, + 507, + 193 + ], + "score": 1.0, + "content": ". Instead, bidirec-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 192, + 506, + 205 + ], + "spans": [ + { + "bbox": [ + 106, + 192, + 318, + 205 + ], + "score": 1.0, + "content": "tional TAP models target all intermediate frames, i.e.,", + "type": "text" + }, + { + "bbox": [ + 319, + 192, + 413, + 204 + ], + "score": 0.91, + "content": "\\mathrm { T } = \\{ 1 , 2 , . . . , \\mathrm { l a s t } - 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 413, + 192, + 506, + 205 + ], + "score": 1.0, + "content": "in Eq 2. As in forward", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 202, + 507, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 507, + 216 + ], + "score": 1.0, + "content": "prediction, the model has incentive to predict predictable frames. In the maze example from Fig 1,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 213, + 397, + 226 + ], + "spans": [ + { + "bbox": [ + 106, + 213, + 397, + 226 + ], + "score": 1.0, + "content": "this would mean producing an image of the agent at one of the asterisks.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 156, + 507, + 226 + ] + }, + { + "type": "title", + "bbox": [ + 106, + 239, + 375, + 251 + ], + "lines": [ + { + "bbox": [ + 106, + 239, + 376, + 252 + ], + "spans": [ + { + "bbox": [ + 106, + 239, + 376, + 252 + ], + "score": 1.0, + "content": "3.2 FROM MINIMUM TO GENERALIZED MINIMUM TAP LOSS", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 259, + 504, + 294 + ], + "lines": [ + { + "bbox": [ + 105, + 259, + 506, + 273 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 506, + 273 + ], + "score": 1.0, + "content": "Within the time-agnostic prediction paradigm, we may still want to specify preferences for some", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 271, + 506, + 284 + ], + "spans": [ + { + "bbox": [ + 106, + 271, + 506, + 284 + ], + "score": 1.0, + "content": "times over others, or for some visual properties of the predictions. Consider the minimum-over-time", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 282, + 383, + 294 + ], + "spans": [ + { + "bbox": [ + 106, + 282, + 124, + 294 + ], + "score": 1.0, + "content": "loss", + "type": "text" + }, + { + "bbox": [ + 125, + 282, + 133, + 292 + ], + "score": 0.8, + "content": "\\mathcal { L }", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 282, + 383, + 294 + ], + "score": 1.0, + "content": "in Eq 2. Taking the minimum inside, this may be rewritten as:", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14, + "bbox_fs": [ + 105, + 259, + 506, + 294 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 237, + 302, + 372, + 321 + ], + "lines": [ + { + "bbox": [ + 237, + 302, + 372, + 321 + ], + "spans": [ + { + "bbox": [ + 237, + 302, + 372, + 321 + ], + "score": 0.93, + "content": "{ \\mathcal { L } } ( G ) = \\operatorname* { m i n } _ { t \\in T } { \\mathcal { E } } _ { t } = { \\mathcal { E } } _ { \\arg \\operatorname* { m i n } _ { t \\in T } { \\mathcal { E } } _ { t } } ,", + "type": "interline_equation", + "image_path": "8e2a838c3ebaff04bc9293bfbab18097ea7233e60e1c1c740e279db5c771141d.jpg" + } + ] + } + ], + "index": 16, + "virtual_lines": [ + { + "bbox": [ + 237, + 302, + 372, + 321 + ], + "spans": [], + "index": 16 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 330, + 504, + 353 + ], + "lines": [ + { + "bbox": [ + 106, + 330, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 330, + 258, + 343 + ], + "score": 1.0, + "content": "where we use the time-indexed error", + "type": "text" + }, + { + "bbox": [ + 259, + 331, + 268, + 342 + ], + "score": 0.88, + "content": "\\mathcal { E } _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 330, + 339, + 343 + ], + "score": 1.0, + "content": "as shorthand for", + "type": "text" + }, + { + "bbox": [ + 339, + 331, + 370, + 343 + ], + "score": 0.92, + "content": "\\mathcal { E } ( . , x _ { t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 330, + 505, + 343 + ], + "score": 1.0, + "content": ". We may now extend this to the", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 341, + 457, + 354 + ], + "spans": [ + { + "bbox": [ + 106, + 341, + 457, + 354 + ], + "score": 1.0, + "content": "following “generalized minimum” loss, where the outer and inner errors are decoupled:", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5, + "bbox_fs": [ + 106, + 330, + 505, + 354 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 256, + 361, + 354, + 378 + ], + "lines": [ + { + "bbox": [ + 256, + 361, + 354, + 378 + ], + "spans": [ + { + "bbox": [ + 256, + 361, + 354, + 378 + ], + "score": 0.92, + "content": "\\begin{array} { r } { \\mathcal { L } ^ { \\prime } ( G ) = \\mathcal { E } _ { \\mathrm { a r g m i n } _ { t \\in T } } \\mathcal { E } _ { t } ^ { \\prime } . } \\end{array}", + "type": "interline_equation", + "image_path": "499b1782e84de4fe899e511693d3a4ad924364cd3e84c6f7b59c9a41ff9e5202.jpg" + } + ] + } + ], + "index": 19, + "virtual_lines": [ + { + "bbox": [ + 256, + 361, + 354, + 378 + ], + "spans": [], + "index": 19 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 386, + 505, + 464 + ], + "lines": [ + { + "bbox": [ + 105, + 385, + 506, + 400 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 131, + 400 + ], + "score": 1.0, + "content": "Now,", + "type": "text" + }, + { + "bbox": [ + 131, + 387, + 141, + 398 + ], + "score": 0.88, + "content": "\\mathcal { E } _ { t } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 385, + 506, + 400 + ], + "score": 1.0, + "content": ", over which the minimum is computed, could be designed to express preferences about", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 398, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 286, + 410 + ], + "score": 1.0, + "content": "which frames to predict. In the simplest case,", + "type": "text" + }, + { + "bbox": [ + 286, + 398, + 319, + 410 + ], + "score": 0.93, + "content": "\\mathcal { E } _ { t } ^ { \\prime } = \\mathcal { E } _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 319, + 398, + 414, + 410 + ], + "score": 1.0, + "content": ", and the loss reduces to", + "type": "text" + }, + { + "bbox": [ + 414, + 398, + 434, + 409 + ], + "score": 0.42, + "content": "\\operatorname { E q } 2", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 398, + 505, + 410 + ], + "score": 1.0, + "content": ". Instead, suppose", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 408, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 344, + 421 + ], + "score": 1.0, + "content": "that predictions at some times are preferred over others. Let", + "type": "text" + }, + { + "bbox": [ + 344, + 409, + 364, + 421 + ], + "score": 0.92, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 408, + 506, + 421 + ], + "score": 1.0, + "content": "express the preference value for all", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 419, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 156, + 433 + ], + "score": 1.0, + "content": "target times", + "type": "text" + }, + { + "bbox": [ + 156, + 420, + 180, + 430 + ], + "score": 0.89, + "content": "t \\in T", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 419, + 241, + 433 + ], + "score": 1.0, + "content": ", so that higher", + "type": "text" + }, + { + "bbox": [ + 242, + 420, + 261, + 432 + ], + "score": 0.91, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 419, + 449, + 433 + ], + "score": 1.0, + "content": "indicates higher preference. Then we may set", + "type": "text" + }, + { + "bbox": [ + 450, + 420, + 505, + 432 + ], + "score": 0.91, + "content": "\\mathcal { E } _ { t } ^ { \\prime } = \\mathcal { E } _ { t } / w ( t )", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 430, + 506, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 161, + 443 + ], + "score": 1.0, + "content": "so that times", + "type": "text" + }, + { + "bbox": [ + 162, + 432, + 167, + 441 + ], + "score": 0.72, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 430, + 218, + 443 + ], + "score": 1.0, + "content": "with higher", + "type": "text" + }, + { + "bbox": [ + 218, + 431, + 238, + 442 + ], + "score": 0.91, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 238, + 430, + 473, + 443 + ], + "score": 1.0, + "content": "are preferred in the arg min. In our experiments, we set", + "type": "text" + }, + { + "bbox": [ + 473, + 432, + 493, + 443 + ], + "score": 0.9, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 493, + 430, + 506, + 443 + ], + "score": 1.0, + "content": "to", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 441, + 506, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 506, + 454 + ], + "score": 1.0, + "content": "linearly increase with time during forward prediction and to a truncated discrete Gaussian centered at", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 452, + 268, + 465 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 268, + 465 + ], + "score": 1.0, + "content": "the midpoint in bidirectional prediction.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 385, + 506, + 465 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 469, + 505, + 536 + ], + "lines": [ + { + "bbox": [ + 106, + 470, + 505, + 481 + ], + "spans": [ + { + "bbox": [ + 106, + 470, + 505, + 481 + ], + "score": 1.0, + "content": "At this point, one might ask: could we not directly incorporate preferences into the outer error?", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 480, + 506, + 493 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 271, + 493 + ], + "score": 1.0, + "content": "For instance, why not simply optimize", + "type": "text" + }, + { + "bbox": [ + 272, + 480, + 329, + 492 + ], + "score": 0.92, + "content": "\\mathrm { m i n } _ { t } \\mathcal { E } _ { t } / w ( t ) ^ { \\star }", + "type": "inline_equation" + }, + { + "bbox": [ + 329, + 480, + 506, + 493 + ], + "score": 1.0, + "content": "? Unfortunately, that would have the side-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 491, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 106, + 491, + 453, + 504 + ], + "score": 1.0, + "content": "effect of downweighting the errors computed against frames with higher preferences", + "type": "text" + }, + { + "bbox": [ + 453, + 491, + 473, + 504 + ], + "score": 0.91, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 474, + 491, + 505, + 504 + ], + "score": 1.0, + "content": ", which", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 501, + 506, + 516 + ], + "spans": [ + { + "bbox": [ + 104, + 501, + 412, + 516 + ], + "score": 1.0, + "content": "is counterproductive. Decoupling the outer and inner errors instead, as in", + "type": "text" + }, + { + "bbox": [ + 412, + 502, + 433, + 514 + ], + "score": 0.36, + "content": "\\operatorname { E q } 5", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 501, + 506, + 516 + ], + "score": 1.0, + "content": ", allows applying", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 513, + 506, + 526 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 154, + 526 + ], + "score": 1.0, + "content": "preferences", + "type": "text" + }, + { + "bbox": [ + 154, + 513, + 174, + 525 + ], + "score": 0.91, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 513, + 506, + 526 + ], + "score": 1.0, + "content": "only to select the target frame to compute the outer loss against; the outer loss itself", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 524, + 407, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 524, + 407, + 536 + ], + "score": 1.0, + "content": "penalizes prediction errors equally regardless of which frame was selected.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 29.5, + "bbox_fs": [ + 104, + 470, + 506, + 536 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 541, + 505, + 586 + ], + "lines": [ + { + "bbox": [ + 106, + 541, + 505, + 553 + ], + "spans": [ + { + "bbox": [ + 106, + 541, + 505, + 553 + ], + "score": 1.0, + "content": "The generalized minimum formulation may be used to express other kinds of preferences too. For", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 553, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 553, + 505, + 565 + ], + "score": 1.0, + "content": "instance, when using predictions as subgoals in a planner, perhaps some states are more expensive to", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 564, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 505, + 576 + ], + "score": 1.0, + "content": "reach than others. We also use the generalized minimum to select frames using different criteria than", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 574, + 339, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 339, + 586 + ], + "score": 1.0, + "content": "the prediction penalty itself, as we will discuss in Sec 3.5.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 541, + 505, + 586 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 599, + 298, + 611 + ], + "lines": [ + { + "bbox": [ + 105, + 598, + 299, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 299, + 613 + ], + "score": 1.0, + "content": "3.3 TIME-AGNOSTIC CONDITIONAL GANS", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 619, + 505, + 686 + ], + "lines": [ + { + "bbox": [ + 105, + 619, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 281, + 632 + ], + "score": 1.0, + "content": "TAP is not limited to simple losses such as", + "type": "text" + }, + { + "bbox": [ + 282, + 620, + 292, + 631 + ], + "score": 0.88, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 292, + 619, + 304, + 632 + ], + "score": 1.0, + "content": "or", + "type": "text" + }, + { + "bbox": [ + 304, + 620, + 314, + 631 + ], + "score": 0.88, + "content": "\\ell _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 619, + 506, + 632 + ], + "score": 1.0, + "content": "errors; it can be extended to handle expressive", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 631, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 106, + 631, + 505, + 644 + ], + "score": 1.0, + "content": "GAN losses to improve perceptual quality. A standard conditional GAN (CGAN) in fixed-time", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 641, + 506, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 236, + 654 + ], + "score": 1.0, + "content": "video prediction targeting time", + "type": "text" + }, + { + "bbox": [ + 236, + 644, + 243, + 651 + ], + "score": 0.77, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 244, + 641, + 420, + 654 + ], + "score": 1.0, + "content": "works as follows: given a “discriminator”", + "type": "text" + }, + { + "bbox": [ + 420, + 642, + 430, + 651 + ], + "score": 0.82, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 430, + 641, + 506, + 654 + ], + "score": 1.0, + "content": "that outputs 0 for", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 653, + 505, + 665 + ], + "spans": [ + { + "bbox": [ + 106, + 653, + 408, + 665 + ], + "score": 1.0, + "content": "input-prediction tuples and 1 for input-ground truth tuples, the generator", + "type": "text" + }, + { + "bbox": [ + 408, + 653, + 417, + 663 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 653, + 505, + 665 + ], + "score": 1.0, + "content": "is trained to fool the", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 663, + 507, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 507, + 676 + ], + "score": 1.0, + "content": "discriminator. The discriminator in turn is trained adversarially using a binary cross-entropy loss.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 675, + 247, + 687 + ], + "spans": [ + { + "bbox": [ + 106, + 675, + 247, + 687 + ], + "score": 1.0, + "content": "The CGAN objective is written as:", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 40.5, + "bbox_fs": [ + 105, + 619, + 507, + 687 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 198, + 694, + 412, + 732 + ], + "lines": [ + { + "bbox": [ + 198, + 694, + 412, + 732 + ], + "spans": [ + { + "bbox": [ + 198, + 694, + 412, + 732 + ], + "score": 0.9, + "content": "\\begin{array} { r l } & { G ^ { * } = \\underset { G } { \\arg \\operatorname* { m i n } } \\ \\underset { D } { \\operatorname* { m a x } } \\mathcal { L } _ { \\mathrm { c g a n } } ( G , D ) , } \\\\ & { } \\\\ & { \\mathcal { L } _ { \\mathrm { c g a n } } ( G , D ) = \\log ( D ( c , x _ { \\tau } ) ) + \\log ( 1 - D ( c , G ( c ) ) } \\end{array}", + "type": "interline_equation", + "image_path": "a344bd70cbb79bd7a16342e2a26baaad21507932570028252c1ff0aaf86ac95f.jpg" + } + ] + } + ], + "index": 44.5, + "virtual_lines": [ + { + "bbox": [ + 198, + 694, + 412, + 713.0 + ], + "spans": [], + "index": 44 + }, + { + "bbox": [ + 198, + 713.0, + 412, + 732.0 + ], + "spans": [], + "index": 45 + } + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 104, + 81, + 505, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 295, + 96 + ], + "score": 1.0, + "content": "To make this compatible with TAP, we train", + "type": "text" + }, + { + "bbox": [ + 296, + 83, + 310, + 95 + ], + "score": 0.86, + "content": "| \\mathrm { T } |", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 81, + 374, + 96 + ], + "score": 1.0, + "content": "discriminators", + "type": "text" + }, + { + "bbox": [ + 374, + 82, + 397, + 95 + ], + "score": 0.92, + "content": "\\{ D _ { t } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 81, + 506, + 96 + ], + "score": 1.0, + "content": ", one per timestep. Then,", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 359, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 159, + 106 + ], + "score": 1.0, + "content": "analogous to", + "type": "text" + }, + { + "bbox": [ + 159, + 94, + 180, + 105 + ], + "score": 0.28, + "content": "\\operatorname { E q } 2", + "type": "inline_equation" + }, + { + "bbox": [ + 180, + 93, + 359, + 106 + ], + "score": 1.0, + "content": ", we may define a time-agnostic CGAN loss:", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "interline_equation", + "bbox": [ + 141, + 111, + 469, + 163 + ], + "lines": [ + { + "bbox": [ + 141, + 111, + 469, + 163 + ], + "spans": [ + { + "bbox": [ + 141, + 111, + 469, + 163 + ], + "score": 0.93, + "content": "\\begin{array} { r l } & { G ^ { * } = \\underset { G } { \\arg \\operatorname* { m i n } } \\underset { t \\in T } { \\operatorname* { m i n } } \\underset { D _ { t } } { \\operatorname* { m a x } } \\mathcal { L } _ { \\mathrm { c g a n } } ^ { t } ( G , D _ { t } ) , } \\\\ & { \\mathcal { L } _ { \\mathrm { c g a n } } ^ { t } ( G , D _ { t } ) = \\log D _ { t } ( c , x _ { t } ) + \\log ( 1 - D _ { t } ( c , G ( c ) ) ) + \\underset { t ^ { \\prime } \\neq t } { \\sum } \\log ( 1 - D _ { t } ( c , x _ { t ^ { \\prime } } ) ) , } \\end{array}", + "type": "interline_equation", + "image_path": "642032ec3b2c5e42befe78ad2d47ede55bef3f7c187593e8ad908907a0646f0a.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 141, + 111, + 469, + 128.33333333333334 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 141, + 128.33333333333334, + 469, + 145.66666666666669 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 141, + 145.66666666666669, + 469, + 163.00000000000003 + ], + "spans": [], + "index": 4 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 169, + 506, + 236 + ], + "lines": [ + { + "bbox": [ + 105, + 169, + 505, + 182 + ], + "spans": [ + { + "bbox": [ + 105, + 169, + 127, + 182 + ], + "score": 1.0, + "content": "Like", + "type": "text" + }, + { + "bbox": [ + 128, + 170, + 173, + 182 + ], + "score": 0.42, + "content": "\\mathrm { E q } 6 , \\mathrm { E q } 7", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 169, + 441, + 182 + ], + "score": 1.0, + "content": "defines a cross-entropy loss. The first two terms are analogous to", + "type": "text" + }, + { + "bbox": [ + 441, + 170, + 462, + 182 + ], + "score": 0.37, + "content": "\\operatorname { E q } 6", + "type": "inline_equation" + }, + { + "bbox": [ + 463, + 169, + 505, + 182 + ], + "score": 1.0, + "content": "— for the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 107, + 180, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 107, + 182, + 111, + 191 + ], + "score": 0.75, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 112, + 180, + 198, + 194 + ], + "score": 1.0, + "content": "-th discriminator, the", + "type": "text" + }, + { + "bbox": [ + 198, + 182, + 203, + 191 + ], + "score": 0.76, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 180, + 505, + 194 + ], + "score": 1.0, + "content": "-th frame provides a positive, and the generated frame provides a negative", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 191, + 507, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 430, + 205 + ], + "score": 1.0, + "content": "instance. The third term treats ground truth video frames occurring at other times", + "type": "text" + }, + { + "bbox": [ + 431, + 193, + 453, + 203 + ], + "score": 0.85, + "content": "x _ { t ^ { \\prime } \\neq t }", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 191, + 507, + 205 + ], + "score": 1.0, + "content": "as negatives.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 202, + 506, + 215 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 332, + 215 + ], + "score": 1.0, + "content": "In practice, we train a single discriminator network with", + "type": "text" + }, + { + "bbox": [ + 332, + 203, + 346, + 215 + ], + "score": 0.9, + "content": "| T |", + "type": "inline_equation" + }, + { + "bbox": [ + 346, + 202, + 430, + 215 + ], + "score": 1.0, + "content": "outputs that serve as", + "type": "text" + }, + { + "bbox": [ + 430, + 204, + 453, + 215 + ], + "score": 0.9, + "content": "\\{ D _ { t } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 202, + 506, + 215 + ], + "score": 1.0, + "content": ". Further, for", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 214, + 505, + 226 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 358, + 226 + ], + "score": 1.0, + "content": "computational efficiency, we approximate the summation over", + "type": "text" + }, + { + "bbox": [ + 359, + 214, + 383, + 225 + ], + "score": 0.91, + "content": "t ^ { \\prime } \\neq t", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 214, + 505, + 226 + ], + "score": 1.0, + "content": "by sampling a single frame at", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 225, + 463, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 463, + 237 + ], + "score": 1.0, + "content": "random for each training video at each iteration. Appendix A provides additional details.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 7.5 + }, + { + "type": "title", + "bbox": [ + 108, + 249, + 296, + 261 + ], + "lines": [ + { + "bbox": [ + 106, + 249, + 297, + 261 + ], + "spans": [ + { + "bbox": [ + 106, + 249, + 297, + 261 + ], + "score": 1.0, + "content": "3.4 TIME-AGNOSTIC CONDITIONAL VAES", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 269, + 505, + 336 + ], + "lines": [ + { + "bbox": [ + 106, + 270, + 505, + 281 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 505, + 281 + ], + "score": 1.0, + "content": "While TAP targets low-uncertainty bottleneck states, it may be integrated with a conditional variational", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 280, + 505, + 293 + ], + "spans": [ + { + "bbox": [ + 105, + 280, + 505, + 293 + ], + "score": 1.0, + "content": "autoencoder (CVAE) to handle residual uncertainty at these bottlenecks. In typical fixed-time CVAE", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 291, + 505, + 304 + ], + "spans": [ + { + "bbox": [ + 105, + 291, + 209, + 304 + ], + "score": 1.0, + "content": "predictors targeting time", + "type": "text" + }, + { + "bbox": [ + 209, + 294, + 216, + 302 + ], + "score": 0.76, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 291, + 327, + 304 + ], + "score": 1.0, + "content": ", variations in a latent code", + "type": "text" + }, + { + "bbox": [ + 328, + 293, + 334, + 301 + ], + "score": 0.77, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 291, + 418, + 304 + ], + "score": 1.0, + "content": "input to a generator", + "type": "text" + }, + { + "bbox": [ + 419, + 293, + 448, + 303 + ], + "score": 0.92, + "content": "G ( c , z )", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 291, + 505, + 304 + ], + "score": 1.0, + "content": "must capture", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 302, + 506, + 315 + ], + "spans": [ + { + "bbox": [ + 104, + 302, + 172, + 315 + ], + "score": 1.0, + "content": "stochasticity in", + "type": "text" + }, + { + "bbox": [ + 172, + 304, + 184, + 313 + ], + "score": 0.86, + "content": "x _ { \\tau }", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 302, + 266, + 315 + ], + "score": 1.0, + "content": ". At training time,", + "type": "text" + }, + { + "bbox": [ + 266, + 304, + 273, + 312 + ], + "score": 0.73, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 302, + 444, + 315 + ], + "score": 1.0, + "content": "is sampled from a posterior distribution", + "type": "text" + }, + { + "bbox": [ + 445, + 303, + 482, + 315 + ], + "score": 0.89, + "content": "q _ { \\phi } ( z | x _ { \\tau } )", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 302, + 506, + 315 + ], + "score": 1.0, + "content": "with", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 313, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 154, + 326 + ], + "score": 1.0, + "content": "parameters", + "type": "text" + }, + { + "bbox": [ + 154, + 314, + 161, + 325 + ], + "score": 0.85, + "content": "\\phi", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 313, + 356, + 326 + ], + "score": 1.0, + "content": ", represented by a neural network. At test time,", + "type": "text" + }, + { + "bbox": [ + 356, + 315, + 362, + 323 + ], + "score": 0.79, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 313, + 462, + 326 + ], + "score": 1.0, + "content": "is sampled from a prior", + "type": "text" + }, + { + "bbox": [ + 463, + 315, + 481, + 325 + ], + "score": 0.89, + "content": "p ( z )", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 313, + 505, + 326 + ], + "score": 1.0, + "content": ". The", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 324, + 436, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 436, + 338 + ], + "score": 1.0, + "content": "training loss combines a log-likelihood term with a KL-divergence from the prior:", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14.5 + }, + { + "type": "interline_equation", + "bbox": [ + 170, + 343, + 440, + 359 + ], + "lines": [ + { + "bbox": [ + 170, + 343, + 440, + 359 + ], + "spans": [ + { + "bbox": [ + 170, + 343, + 440, + 359 + ], + "score": 0.88, + "content": "\\begin{array} { r } { \\mathcal { L } _ { \\mathrm { c v a e } } ( G , \\phi ) = D _ { K L } ( q _ { \\phi } ( z | x _ { \\tau } ) , p ( z ) ) - \\mathbb { E } _ { z \\sim q _ { \\phi } ( z | x _ { \\tau } ) } \\ln p _ { G } ( x _ { \\tau } | c , z ) , } \\end{array}", + "type": "interline_equation", + "image_path": "b6d76c5d7212d1973d6ab06b4a20053e8b9be5d284c7da59a31de2a21fdaba9c.jpg" + } + ] + } + ], + "index": 18, + "virtual_lines": [ + { + "bbox": [ + 170, + 343, + 440, + 359 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 365, + 506, + 443 + ], + "lines": [ + { + "bbox": [ + 106, + 366, + 506, + 378 + ], + "spans": [ + { + "bbox": [ + 106, + 366, + 193, + 378 + ], + "score": 1.0, + "content": "where we might set", + "type": "text" + }, + { + "bbox": [ + 194, + 368, + 207, + 377 + ], + "score": 0.85, + "content": "p _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 207, + 366, + 492, + 378 + ], + "score": 1.0, + "content": "to a Laplacian distribution such that the second term reduces to a", + "type": "text" + }, + { + "bbox": [ + 493, + 366, + 502, + 376 + ], + "score": 0.54, + "content": "l 1", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 366, + 506, + 378 + ], + "score": 1.0, + "content": "-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 376, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 377, + 187, + 389 + ], + "score": 1.0, + "content": "reconstruction loss", + "type": "text" + }, + { + "bbox": [ + 187, + 376, + 339, + 389 + ], + "score": 0.89, + "content": "- \\ln p _ { G } ( x _ { \\tau } | \\bar { c , { z } } ) = \\| \\boldsymbol { G } ( c , { z } ) - \\boldsymbol { x } _ { \\tau } \\| _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 377, + 505, + 389 + ], + "score": 1.0, + "content": ". In a time-agnostic CVAE, rather than", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 387, + 506, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 387, + 257, + 401 + ], + "score": 1.0, + "content": "capturing stochasticity at a fixed time", + "type": "text" + }, + { + "bbox": [ + 258, + 390, + 264, + 398 + ], + "score": 0.68, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 387, + 268, + 401 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 268, + 390, + 275, + 398 + ], + "score": 0.65, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 275, + 387, + 506, + 401 + ], + "score": 1.0, + "content": "must now capture stochasticity at bottlenecks: e.g., when", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 312, + 411 + ], + "score": 1.0, + "content": "the agent crosses one of the asterisks in the maze of", + "type": "text" + }, + { + "bbox": [ + 313, + 399, + 334, + 410 + ], + "score": 0.26, + "content": "\\mathrm { F i g ~ 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 398, + 505, + 411 + ], + "score": 1.0, + "content": ", which pose is it in? The bottleneck’s time", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 409, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 409, + 505, + 423 + ], + "score": 1.0, + "content": "index varies and is not known in advance. For computational reasons (see Appendix B), we pass", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 420, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 105, + 420, + 171, + 433 + ], + "score": 1.0, + "content": "the entire video", + "type": "text" + }, + { + "bbox": [ + 171, + 421, + 181, + 430 + ], + "score": 0.83, + "content": "X", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 420, + 289, + 433 + ], + "score": 1.0, + "content": "into the inference network", + "type": "text" + }, + { + "bbox": [ + 289, + 422, + 300, + 433 + ], + "score": 0.86, + "content": "q _ { \\phi }", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 420, + 505, + 433 + ], + "score": 1.0, + "content": ", similar to Babaeizadeh et al. (2018). The negative", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 432, + 344, + 444 + ], + "spans": [ + { + "bbox": [ + 106, + 432, + 344, + 444 + ], + "score": 1.0, + "content": "log-likelihood term is adapted to be a minimum-over-time:", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22 + }, + { + "type": "interline_equation", + "bbox": [ + 155, + 451, + 455, + 470 + ], + "lines": [ + { + "bbox": [ + 155, + 451, + 455, + 470 + ], + "spans": [ + { + "bbox": [ + 155, + 451, + 455, + 470 + ], + "score": 0.91, + "content": "\\mathcal { L } _ { \\mathrm { c v a e } } ( G , \\phi ) = D _ { K L } ( q _ { \\phi } ( z | X ) , p ( z ) ) + \\operatorname* { m i n } _ { t \\in \\mathbb { T } } \\mathbb { E } _ { z \\sim q _ { \\phi } ( z | X ) } \\left[ - \\ln p _ { G } ( x _ { t } | c , z ) \\right] .", + "type": "interline_equation", + "image_path": "e2f011e4146b6cc813ecc2a11f1d6b637c34936b5589f7d57964fdc9b232252f.jpg" + } + ] + } + ], + "index": 26, + "virtual_lines": [ + { + "bbox": [ + 155, + 451, + 455, + 470 + ], + "spans": [], + "index": 26 + } + ] + }, + { + "type": "title", + "bbox": [ + 107, + 487, + 396, + 500 + ], + "lines": [ + { + "bbox": [ + 105, + 487, + 397, + 501 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 397, + 501 + ], + "score": 1.0, + "content": "3.5 COMBINED LOSS, NETWORK ARCHITECTURE, AND TRAINING", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 105, + 507, + 504, + 531 + ], + "lines": [ + { + "bbox": [ + 106, + 507, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 106, + 507, + 505, + 520 + ], + "score": 1.0, + "content": "We train time-agnostic CVAE-GANs with the following combination of a generalized minimum loss", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 519, + 325, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 519, + 325, + 532 + ], + "score": 1.0, + "content": "(Sec 3.2) and the CVAE KL divergence loss (Sec 3.4):", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28.5 + }, + { + "type": "interline_equation", + "bbox": [ + 175, + 536, + 435, + 597 + ], + "lines": [ + { + "bbox": [ + 175, + 536, + 435, + 597 + ], + "spans": [ + { + "bbox": [ + 175, + 536, + 435, + 597 + ], + "score": 0.94, + "content": "\\begin{array} { r l } & { G ^ { * } = \\underset { G } { \\arg \\operatorname* { m i n } } \\underset { \\phi } { \\operatorname* { m i n } } \\left[ D _ { K L } ( q _ { \\phi } ( \\boldsymbol { z } | \\boldsymbol { X } ) , p ( \\boldsymbol { z } ) ) + \\mathcal { E } _ { \\mathrm { a r g } \\operatorname* { m i n } _ { t \\in \\mathbb { T } } } \\varepsilon _ { t } ^ { \\prime } \\right] , } \\\\ & { \\mathcal { E } _ { t } = \\underset { D , D ^ { \\prime } } { \\operatorname* { m a x } } \\mathcal { L } _ { \\mathrm { c g a n } } ^ { t } ( G , D _ { t } ) + \\mathcal { L } _ { \\mathrm { c v a e - g a n } } ^ { t } ( G , D _ { t } ^ { \\prime } ) + \\| G ( \\boldsymbol { c } , \\boldsymbol { z } ) - x _ { t } \\| _ { 1 } , } \\\\ & { \\mathcal { E } _ { t } ^ { \\prime } = \\| G ( \\boldsymbol { c } , \\boldsymbol { z } ) - x _ { t } \\| _ { 1 } / w ( t ) . } \\end{array}", + "type": "interline_equation", + "image_path": "cce1881ed319695652dcf6e898c2cb7e7029038e0b7b830af098a8f74e1e396c.jpg" + } + ] + } + ], + "index": 31, + "virtual_lines": [ + { + "bbox": [ + 175, + 536, + 435, + 556.3333333333334 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 175, + 556.3333333333334, + 435, + 576.6666666666667 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 175, + 576.6666666666667, + 435, + 597.0000000000001 + ], + "spans": [], + "index": 32 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 602, + 505, + 695 + ], + "lines": [ + { + "bbox": [ + 106, + 603, + 506, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 603, + 171, + 615 + ], + "score": 1.0, + "content": "The outer error", + "type": "text" + }, + { + "bbox": [ + 171, + 604, + 181, + 614 + ], + "score": 0.87, + "content": "\\mathcal { E } _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 603, + 476, + 615 + ], + "score": 1.0, + "content": "absorbs the CGAN discriminator errors (Sec 3.3), while the inner error", + "type": "text" + }, + { + "bbox": [ + 477, + 603, + 487, + 615 + ], + "score": 0.88, + "content": "\\mathcal { E } _ { t } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 603, + 506, + 615 + ], + "score": 1.0, + "content": "is a", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 614, + 505, + 626 + ], + "spans": [ + { + "bbox": [ + 106, + 614, + 136, + 626 + ], + "score": 1.0, + "content": "simple", + "type": "text" + }, + { + "bbox": [ + 136, + 614, + 146, + 625 + ], + "score": 0.87, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 614, + 354, + 626 + ], + "score": 1.0, + "content": "error, weighted by user-specified time preferences", + "type": "text" + }, + { + "bbox": [ + 354, + 614, + 374, + 626 + ], + "score": 0.91, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 614, + 505, + 626 + ], + "score": 1.0, + "content": "(Sec 3.2). Omitting GAN error", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 624, + 505, + 638 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 142, + 638 + ], + "score": 1.0, + "content": "terms in", + "type": "text" + }, + { + "bbox": [ + 142, + 625, + 153, + 637 + ], + "score": 0.89, + "content": "\\mathcal { E } _ { t } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 153, + 624, + 505, + 638 + ], + "score": 1.0, + "content": "helps stabilize training, since learned errors may not always be meaningful especially", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 101, + 636, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 101, + 641, + 144, + 679 + ], + "score": 1.0, + "content": "includesthe prior", + "type": "text" + }, + { + "bbox": [ + 106, + 636, + 505, + 649 + ], + "score": 1.0, + "content": "early on in training. As in VAE-GANs (Larsen et al., 2016; Lee et al., 2018), the training objective", + "type": "text" + }, + { + "bbox": [ + 163, + 641, + 191, + 679 + ], + "score": 1.0, + "content": "w term , while", + "type": "text" + }, + { + "bbox": [ + 193, + 647, + 226, + 659 + ], + "score": 0.92, + "content": "\\mathcal { L } _ { \\mathrm { c v a e - g a n } } ^ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 226, + 641, + 286, + 679 + ], + "score": 1.0, + "content": ", analogous to instead sample", + "type": "text" + }, + { + "bbox": [ + 286, + 647, + 308, + 660 + ], + "score": 0.9, + "content": "\\mathcal { L } _ { \\mathrm { c g a n } } ^ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 641, + 376, + 679 + ], + "score": 1.0, + "content": "(Eq 7). We set om the posterior", + "type": "text" + }, + { + "bbox": [ + 388, + 647, + 409, + 659 + ], + "score": 0.91, + "content": "\\mathcal { L } _ { \\mathrm { c g a n } } ^ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 412, + 641, + 474, + 679 + ], + "score": 1.0, + "content": "to use samples , and employs s", + "type": "text" + }, + { + "bbox": [ + 474, + 649, + 481, + 657 + ], + "score": 0.75, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 641, + 505, + 679 + ], + "score": 1.0, + "content": "fromarate", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 144, + 659, + 411, + 672 + ], + "spans": [ + { + "bbox": [ + 144, + 659, + 162, + 672 + ], + "score": 0.92, + "content": "p ( z )", + "type": "inline_equation" + }, + { + "bbox": [ + 192, + 660, + 225, + 672 + ], + "score": 0.91, + "content": "\\mathcal { L } _ { \\mathrm { c v a e - g a n } } ^ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 293, + 662, + 299, + 669 + ], + "score": 0.78, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 660, + 411, + 672 + ], + "score": 0.93, + "content": "q _ { \\phi } ( z | X )", + "type": "inline_equation" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 671, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 167, + 685 + ], + "score": 1.0, + "content": "discriminators", + "type": "text" + }, + { + "bbox": [ + 167, + 672, + 189, + 684 + ], + "score": 0.92, + "content": "\\{ D _ { t } ^ { \\prime } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 671, + 212, + 685 + ], + "score": 1.0, + "content": ". The", + "type": "text" + }, + { + "bbox": [ + 212, + 673, + 222, + 683 + ], + "score": 0.86, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 671, + 295, + 685 + ], + "score": 1.0, + "content": "loss also samples", + "type": "text" + }, + { + "bbox": [ + 295, + 675, + 302, + 682 + ], + "score": 0.76, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 302, + 671, + 505, + 685 + ], + "score": 1.0, + "content": "from the posterior. We omit expectations over the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 682, + 258, + 696 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 152, + 696 + ], + "score": 1.0, + "content": "VAE latent", + "type": "text" + }, + { + "bbox": [ + 153, + 685, + 159, + 693 + ], + "score": 0.76, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 682, + 258, + 696 + ], + "score": 1.0, + "content": "to keep notation simple.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36 + }, + { + "type": "text", + "bbox": [ + 107, + 700, + 505, + 734 + ], + "lines": [ + { + "bbox": [ + 105, + 700, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 700, + 506, + 713 + ], + "score": 1.0, + "content": "Frame generation in the predictor involves first generating appearance flow-transformed input", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "frames (Zhou et al., 2016) and a frame with new uncopied pixels. These frames are masked and", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 722, + 460, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 722, + 460, + 734 + ], + "score": 1.0, + "content": "averaged to produce the output. Full architecture and training details are in Appendix C.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 26, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 104, + 81, + 505, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 295, + 96 + ], + "score": 1.0, + "content": "To make this compatible with TAP, we train", + "type": "text" + }, + { + "bbox": [ + 296, + 83, + 310, + 95 + ], + "score": 0.86, + "content": "| \\mathrm { T } |", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 81, + 374, + 96 + ], + "score": 1.0, + "content": "discriminators", + "type": "text" + }, + { + "bbox": [ + 374, + 82, + 397, + 95 + ], + "score": 0.92, + "content": "\\{ D _ { t } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 81, + 506, + 96 + ], + "score": 1.0, + "content": ", one per timestep. Then,", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 359, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 159, + 106 + ], + "score": 1.0, + "content": "analogous to", + "type": "text" + }, + { + "bbox": [ + 159, + 94, + 180, + 105 + ], + "score": 0.28, + "content": "\\operatorname { E q } 2", + "type": "inline_equation" + }, + { + "bbox": [ + 180, + 93, + 359, + 106 + ], + "score": 1.0, + "content": ", we may define a time-agnostic CGAN loss:", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 105, + 81, + 506, + 106 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 141, + 111, + 469, + 163 + ], + "lines": [ + { + "bbox": [ + 141, + 111, + 469, + 163 + ], + "spans": [ + { + "bbox": [ + 141, + 111, + 469, + 163 + ], + "score": 0.93, + "content": "\\begin{array} { r l } & { G ^ { * } = \\underset { G } { \\arg \\operatorname* { m i n } } \\underset { t \\in T } { \\operatorname* { m i n } } \\underset { D _ { t } } { \\operatorname* { m a x } } \\mathcal { L } _ { \\mathrm { c g a n } } ^ { t } ( G , D _ { t } ) , } \\\\ & { \\mathcal { L } _ { \\mathrm { c g a n } } ^ { t } ( G , D _ { t } ) = \\log D _ { t } ( c , x _ { t } ) + \\log ( 1 - D _ { t } ( c , G ( c ) ) ) + \\underset { t ^ { \\prime } \\neq t } { \\sum } \\log ( 1 - D _ { t } ( c , x _ { t ^ { \\prime } } ) ) , } \\end{array}", + "type": "interline_equation", + "image_path": "642032ec3b2c5e42befe78ad2d47ede55bef3f7c187593e8ad908907a0646f0a.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 141, + 111, + 469, + 128.33333333333334 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 141, + 128.33333333333334, + 469, + 145.66666666666669 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 141, + 145.66666666666669, + 469, + 163.00000000000003 + ], + "spans": [], + "index": 4 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 169, + 506, + 236 + ], + "lines": [ + { + "bbox": [ + 105, + 169, + 505, + 182 + ], + "spans": [ + { + "bbox": [ + 105, + 169, + 127, + 182 + ], + "score": 1.0, + "content": "Like", + "type": "text" + }, + { + "bbox": [ + 128, + 170, + 173, + 182 + ], + "score": 0.42, + "content": "\\mathrm { E q } 6 , \\mathrm { E q } 7", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 169, + 441, + 182 + ], + "score": 1.0, + "content": "defines a cross-entropy loss. The first two terms are analogous to", + "type": "text" + }, + { + "bbox": [ + 441, + 170, + 462, + 182 + ], + "score": 0.37, + "content": "\\operatorname { E q } 6", + "type": "inline_equation" + }, + { + "bbox": [ + 463, + 169, + 505, + 182 + ], + "score": 1.0, + "content": "— for the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 107, + 180, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 107, + 182, + 111, + 191 + ], + "score": 0.75, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 112, + 180, + 198, + 194 + ], + "score": 1.0, + "content": "-th discriminator, the", + "type": "text" + }, + { + "bbox": [ + 198, + 182, + 203, + 191 + ], + "score": 0.76, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 180, + 505, + 194 + ], + "score": 1.0, + "content": "-th frame provides a positive, and the generated frame provides a negative", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 191, + 507, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 430, + 205 + ], + "score": 1.0, + "content": "instance. The third term treats ground truth video frames occurring at other times", + "type": "text" + }, + { + "bbox": [ + 431, + 193, + 453, + 203 + ], + "score": 0.85, + "content": "x _ { t ^ { \\prime } \\neq t }", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 191, + 507, + 205 + ], + "score": 1.0, + "content": "as negatives.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 202, + 506, + 215 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 332, + 215 + ], + "score": 1.0, + "content": "In practice, we train a single discriminator network with", + "type": "text" + }, + { + "bbox": [ + 332, + 203, + 346, + 215 + ], + "score": 0.9, + "content": "| T |", + "type": "inline_equation" + }, + { + "bbox": [ + 346, + 202, + 430, + 215 + ], + "score": 1.0, + "content": "outputs that serve as", + "type": "text" + }, + { + "bbox": [ + 430, + 204, + 453, + 215 + ], + "score": 0.9, + "content": "\\{ D _ { t } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 202, + 506, + 215 + ], + "score": 1.0, + "content": ". Further, for", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 214, + 505, + 226 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 358, + 226 + ], + "score": 1.0, + "content": "computational efficiency, we approximate the summation over", + "type": "text" + }, + { + "bbox": [ + 359, + 214, + 383, + 225 + ], + "score": 0.91, + "content": "t ^ { \\prime } \\neq t", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 214, + 505, + 226 + ], + "score": 1.0, + "content": "by sampling a single frame at", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 225, + 463, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 463, + 237 + ], + "score": 1.0, + "content": "random for each training video at each iteration. Appendix A provides additional details.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 7.5, + "bbox_fs": [ + 105, + 169, + 507, + 237 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 249, + 296, + 261 + ], + "lines": [ + { + "bbox": [ + 106, + 249, + 297, + 261 + ], + "spans": [ + { + "bbox": [ + 106, + 249, + 297, + 261 + ], + "score": 1.0, + "content": "3.4 TIME-AGNOSTIC CONDITIONAL VAES", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 269, + 505, + 336 + ], + "lines": [ + { + "bbox": [ + 106, + 270, + 505, + 281 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 505, + 281 + ], + "score": 1.0, + "content": "While TAP targets low-uncertainty bottleneck states, it may be integrated with a conditional variational", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 280, + 505, + 293 + ], + "spans": [ + { + "bbox": [ + 105, + 280, + 505, + 293 + ], + "score": 1.0, + "content": "autoencoder (CVAE) to handle residual uncertainty at these bottlenecks. In typical fixed-time CVAE", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 291, + 505, + 304 + ], + "spans": [ + { + "bbox": [ + 105, + 291, + 209, + 304 + ], + "score": 1.0, + "content": "predictors targeting time", + "type": "text" + }, + { + "bbox": [ + 209, + 294, + 216, + 302 + ], + "score": 0.76, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 291, + 327, + 304 + ], + "score": 1.0, + "content": ", variations in a latent code", + "type": "text" + }, + { + "bbox": [ + 328, + 293, + 334, + 301 + ], + "score": 0.77, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 291, + 418, + 304 + ], + "score": 1.0, + "content": "input to a generator", + "type": "text" + }, + { + "bbox": [ + 419, + 293, + 448, + 303 + ], + "score": 0.92, + "content": "G ( c , z )", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 291, + 505, + 304 + ], + "score": 1.0, + "content": "must capture", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 302, + 506, + 315 + ], + "spans": [ + { + "bbox": [ + 104, + 302, + 172, + 315 + ], + "score": 1.0, + "content": "stochasticity in", + "type": "text" + }, + { + "bbox": [ + 172, + 304, + 184, + 313 + ], + "score": 0.86, + "content": "x _ { \\tau }", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 302, + 266, + 315 + ], + "score": 1.0, + "content": ". At training time,", + "type": "text" + }, + { + "bbox": [ + 266, + 304, + 273, + 312 + ], + "score": 0.73, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 302, + 444, + 315 + ], + "score": 1.0, + "content": "is sampled from a posterior distribution", + "type": "text" + }, + { + "bbox": [ + 445, + 303, + 482, + 315 + ], + "score": 0.89, + "content": "q _ { \\phi } ( z | x _ { \\tau } )", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 302, + 506, + 315 + ], + "score": 1.0, + "content": "with", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 313, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 154, + 326 + ], + "score": 1.0, + "content": "parameters", + "type": "text" + }, + { + "bbox": [ + 154, + 314, + 161, + 325 + ], + "score": 0.85, + "content": "\\phi", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 313, + 356, + 326 + ], + "score": 1.0, + "content": ", represented by a neural network. At test time,", + "type": "text" + }, + { + "bbox": [ + 356, + 315, + 362, + 323 + ], + "score": 0.79, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 313, + 462, + 326 + ], + "score": 1.0, + "content": "is sampled from a prior", + "type": "text" + }, + { + "bbox": [ + 463, + 315, + 481, + 325 + ], + "score": 0.89, + "content": "p ( z )", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 313, + 505, + 326 + ], + "score": 1.0, + "content": ". The", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 324, + 436, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 436, + 338 + ], + "score": 1.0, + "content": "training loss combines a log-likelihood term with a KL-divergence from the prior:", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14.5, + "bbox_fs": [ + 104, + 270, + 506, + 338 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 170, + 343, + 440, + 359 + ], + "lines": [ + { + "bbox": [ + 170, + 343, + 440, + 359 + ], + "spans": [ + { + "bbox": [ + 170, + 343, + 440, + 359 + ], + "score": 0.88, + "content": "\\begin{array} { r } { \\mathcal { L } _ { \\mathrm { c v a e } } ( G , \\phi ) = D _ { K L } ( q _ { \\phi } ( z | x _ { \\tau } ) , p ( z ) ) - \\mathbb { E } _ { z \\sim q _ { \\phi } ( z | x _ { \\tau } ) } \\ln p _ { G } ( x _ { \\tau } | c , z ) , } \\end{array}", + "type": "interline_equation", + "image_path": "b6d76c5d7212d1973d6ab06b4a20053e8b9be5d284c7da59a31de2a21fdaba9c.jpg" + } + ] + } + ], + "index": 18, + "virtual_lines": [ + { + "bbox": [ + 170, + 343, + 440, + 359 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 365, + 506, + 443 + ], + "lines": [ + { + "bbox": [ + 106, + 366, + 506, + 378 + ], + "spans": [ + { + "bbox": [ + 106, + 366, + 193, + 378 + ], + "score": 1.0, + "content": "where we might set", + "type": "text" + }, + { + "bbox": [ + 194, + 368, + 207, + 377 + ], + "score": 0.85, + "content": "p _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 207, + 366, + 492, + 378 + ], + "score": 1.0, + "content": "to a Laplacian distribution such that the second term reduces to a", + "type": "text" + }, + { + "bbox": [ + 493, + 366, + 502, + 376 + ], + "score": 0.54, + "content": "l 1", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 366, + 506, + 378 + ], + "score": 1.0, + "content": "-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 376, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 377, + 187, + 389 + ], + "score": 1.0, + "content": "reconstruction loss", + "type": "text" + }, + { + "bbox": [ + 187, + 376, + 339, + 389 + ], + "score": 0.89, + "content": "- \\ln p _ { G } ( x _ { \\tau } | \\bar { c , { z } } ) = \\| \\boldsymbol { G } ( c , { z } ) - \\boldsymbol { x } _ { \\tau } \\| _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 377, + 505, + 389 + ], + "score": 1.0, + "content": ". In a time-agnostic CVAE, rather than", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 387, + 506, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 387, + 257, + 401 + ], + "score": 1.0, + "content": "capturing stochasticity at a fixed time", + "type": "text" + }, + { + "bbox": [ + 258, + 390, + 264, + 398 + ], + "score": 0.68, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 387, + 268, + 401 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 268, + 390, + 275, + 398 + ], + "score": 0.65, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 275, + 387, + 506, + 401 + ], + "score": 1.0, + "content": "must now capture stochasticity at bottlenecks: e.g., when", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 312, + 411 + ], + "score": 1.0, + "content": "the agent crosses one of the asterisks in the maze of", + "type": "text" + }, + { + "bbox": [ + 313, + 399, + 334, + 410 + ], + "score": 0.26, + "content": "\\mathrm { F i g ~ 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 398, + 505, + 411 + ], + "score": 1.0, + "content": ", which pose is it in? The bottleneck’s time", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 409, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 409, + 505, + 423 + ], + "score": 1.0, + "content": "index varies and is not known in advance. For computational reasons (see Appendix B), we pass", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 420, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 105, + 420, + 171, + 433 + ], + "score": 1.0, + "content": "the entire video", + "type": "text" + }, + { + "bbox": [ + 171, + 421, + 181, + 430 + ], + "score": 0.83, + "content": "X", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 420, + 289, + 433 + ], + "score": 1.0, + "content": "into the inference network", + "type": "text" + }, + { + "bbox": [ + 289, + 422, + 300, + 433 + ], + "score": 0.86, + "content": "q _ { \\phi }", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 420, + 505, + 433 + ], + "score": 1.0, + "content": ", similar to Babaeizadeh et al. (2018). The negative", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 432, + 344, + 444 + ], + "spans": [ + { + "bbox": [ + 106, + 432, + 344, + 444 + ], + "score": 1.0, + "content": "log-likelihood term is adapted to be a minimum-over-time:", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22, + "bbox_fs": [ + 105, + 366, + 506, + 444 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 155, + 451, + 455, + 470 + ], + "lines": [ + { + "bbox": [ + 155, + 451, + 455, + 470 + ], + "spans": [ + { + "bbox": [ + 155, + 451, + 455, + 470 + ], + "score": 0.91, + "content": "\\mathcal { L } _ { \\mathrm { c v a e } } ( G , \\phi ) = D _ { K L } ( q _ { \\phi } ( z | X ) , p ( z ) ) + \\operatorname* { m i n } _ { t \\in \\mathbb { T } } \\mathbb { E } _ { z \\sim q _ { \\phi } ( z | X ) } \\left[ - \\ln p _ { G } ( x _ { t } | c , z ) \\right] .", + "type": "interline_equation", + "image_path": "e2f011e4146b6cc813ecc2a11f1d6b637c34936b5589f7d57964fdc9b232252f.jpg" + } + ] + } + ], + "index": 26, + "virtual_lines": [ + { + "bbox": [ + 155, + 451, + 455, + 470 + ], + "spans": [], + "index": 26 + } + ] + }, + { + "type": "title", + "bbox": [ + 107, + 487, + 396, + 500 + ], + "lines": [ + { + "bbox": [ + 105, + 487, + 397, + 501 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 397, + 501 + ], + "score": 1.0, + "content": "3.5 COMBINED LOSS, NETWORK ARCHITECTURE, AND TRAINING", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 105, + 507, + 504, + 531 + ], + "lines": [ + { + "bbox": [ + 106, + 507, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 106, + 507, + 505, + 520 + ], + "score": 1.0, + "content": "We train time-agnostic CVAE-GANs with the following combination of a generalized minimum loss", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 519, + 325, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 519, + 325, + 532 + ], + "score": 1.0, + "content": "(Sec 3.2) and the CVAE KL divergence loss (Sec 3.4):", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28.5, + "bbox_fs": [ + 106, + 507, + 505, + 532 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 175, + 536, + 435, + 597 + ], + "lines": [ + { + "bbox": [ + 175, + 536, + 435, + 597 + ], + "spans": [ + { + "bbox": [ + 175, + 536, + 435, + 597 + ], + "score": 0.94, + "content": "\\begin{array} { r l } & { G ^ { * } = \\underset { G } { \\arg \\operatorname* { m i n } } \\underset { \\phi } { \\operatorname* { m i n } } \\left[ D _ { K L } ( q _ { \\phi } ( \\boldsymbol { z } | \\boldsymbol { X } ) , p ( \\boldsymbol { z } ) ) + \\mathcal { E } _ { \\mathrm { a r g } \\operatorname* { m i n } _ { t \\in \\mathbb { T } } } \\varepsilon _ { t } ^ { \\prime } \\right] , } \\\\ & { \\mathcal { E } _ { t } = \\underset { D , D ^ { \\prime } } { \\operatorname* { m a x } } \\mathcal { L } _ { \\mathrm { c g a n } } ^ { t } ( G , D _ { t } ) + \\mathcal { L } _ { \\mathrm { c v a e - g a n } } ^ { t } ( G , D _ { t } ^ { \\prime } ) + \\| G ( \\boldsymbol { c } , \\boldsymbol { z } ) - x _ { t } \\| _ { 1 } , } \\\\ & { \\mathcal { E } _ { t } ^ { \\prime } = \\| G ( \\boldsymbol { c } , \\boldsymbol { z } ) - x _ { t } \\| _ { 1 } / w ( t ) . } \\end{array}", + "type": "interline_equation", + "image_path": "cce1881ed319695652dcf6e898c2cb7e7029038e0b7b830af098a8f74e1e396c.jpg" + } + ] + } + ], + "index": 31, + "virtual_lines": [ + { + "bbox": [ + 175, + 536, + 435, + 556.3333333333334 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 175, + 556.3333333333334, + 435, + 576.6666666666667 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 175, + 576.6666666666667, + 435, + 597.0000000000001 + ], + "spans": [], + "index": 32 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 602, + 505, + 695 + ], + "lines": [ + { + "bbox": [ + 106, + 603, + 506, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 603, + 171, + 615 + ], + "score": 1.0, + "content": "The outer error", + "type": "text" + }, + { + "bbox": [ + 171, + 604, + 181, + 614 + ], + "score": 0.87, + "content": "\\mathcal { E } _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 603, + 476, + 615 + ], + "score": 1.0, + "content": "absorbs the CGAN discriminator errors (Sec 3.3), while the inner error", + "type": "text" + }, + { + "bbox": [ + 477, + 603, + 487, + 615 + ], + "score": 0.88, + "content": "\\mathcal { E } _ { t } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 603, + 506, + 615 + ], + "score": 1.0, + "content": "is a", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 614, + 505, + 626 + ], + "spans": [ + { + "bbox": [ + 106, + 614, + 136, + 626 + ], + "score": 1.0, + "content": "simple", + "type": "text" + }, + { + "bbox": [ + 136, + 614, + 146, + 625 + ], + "score": 0.87, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 614, + 354, + 626 + ], + "score": 1.0, + "content": "error, weighted by user-specified time preferences", + "type": "text" + }, + { + "bbox": [ + 354, + 614, + 374, + 626 + ], + "score": 0.91, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 614, + 505, + 626 + ], + "score": 1.0, + "content": "(Sec 3.2). Omitting GAN error", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 624, + 505, + 638 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 142, + 638 + ], + "score": 1.0, + "content": "terms in", + "type": "text" + }, + { + "bbox": [ + 142, + 625, + 153, + 637 + ], + "score": 0.89, + "content": "\\mathcal { E } _ { t } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 153, + 624, + 505, + 638 + ], + "score": 1.0, + "content": "helps stabilize training, since learned errors may not always be meaningful especially", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 101, + 636, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 101, + 641, + 144, + 679 + ], + "score": 1.0, + "content": "includesthe prior", + "type": "text" + }, + { + "bbox": [ + 106, + 636, + 505, + 649 + ], + "score": 1.0, + "content": "early on in training. As in VAE-GANs (Larsen et al., 2016; Lee et al., 2018), the training objective", + "type": "text" + }, + { + "bbox": [ + 163, + 641, + 191, + 679 + ], + "score": 1.0, + "content": "w term , while", + "type": "text" + }, + { + "bbox": [ + 193, + 647, + 226, + 659 + ], + "score": 0.92, + "content": "\\mathcal { L } _ { \\mathrm { c v a e - g a n } } ^ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 226, + 641, + 286, + 679 + ], + "score": 1.0, + "content": ", analogous to instead sample", + "type": "text" + }, + { + "bbox": [ + 286, + 647, + 308, + 660 + ], + "score": 0.9, + "content": "\\mathcal { L } _ { \\mathrm { c g a n } } ^ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 641, + 376, + 679 + ], + "score": 1.0, + "content": "(Eq 7). We set om the posterior", + "type": "text" + }, + { + "bbox": [ + 388, + 647, + 409, + 659 + ], + "score": 0.91, + "content": "\\mathcal { L } _ { \\mathrm { c g a n } } ^ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 412, + 641, + 474, + 679 + ], + "score": 1.0, + "content": "to use samples , and employs s", + "type": "text" + }, + { + "bbox": [ + 474, + 649, + 481, + 657 + ], + "score": 0.75, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 641, + 505, + 679 + ], + "score": 1.0, + "content": "fromarate", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 144, + 659, + 411, + 672 + ], + "spans": [ + { + "bbox": [ + 144, + 659, + 162, + 672 + ], + "score": 0.92, + "content": "p ( z )", + "type": "inline_equation" + }, + { + "bbox": [ + 192, + 660, + 225, + 672 + ], + "score": 0.91, + "content": "\\mathcal { L } _ { \\mathrm { c v a e - g a n } } ^ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 293, + 662, + 299, + 669 + ], + "score": 0.78, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 660, + 411, + 672 + ], + "score": 0.93, + "content": "q _ { \\phi } ( z | X )", + "type": "inline_equation" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 671, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 167, + 685 + ], + "score": 1.0, + "content": "discriminators", + "type": "text" + }, + { + "bbox": [ + 167, + 672, + 189, + 684 + ], + "score": 0.92, + "content": "\\{ D _ { t } ^ { \\prime } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 671, + 212, + 685 + ], + "score": 1.0, + "content": ". The", + "type": "text" + }, + { + "bbox": [ + 212, + 673, + 222, + 683 + ], + "score": 0.86, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 671, + 295, + 685 + ], + "score": 1.0, + "content": "loss also samples", + "type": "text" + }, + { + "bbox": [ + 295, + 675, + 302, + 682 + ], + "score": 0.76, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 302, + 671, + 505, + 685 + ], + "score": 1.0, + "content": "from the posterior. We omit expectations over the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 682, + 258, + 696 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 152, + 696 + ], + "score": 1.0, + "content": "VAE latent", + "type": "text" + }, + { + "bbox": [ + 153, + 685, + 159, + 693 + ], + "score": 0.76, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 682, + 258, + 696 + ], + "score": 1.0, + "content": "to keep notation simple.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36, + "bbox_fs": [ + 101, + 603, + 506, + 696 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 700, + 505, + 734 + ], + "lines": [ + { + "bbox": [ + 105, + 700, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 700, + 506, + 713 + ], + "score": 1.0, + "content": "Frame generation in the predictor involves first generating appearance flow-transformed input", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "frames (Zhou et al., 2016) and a frame with new uncopied pixels. These frames are masked and", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 722, + 460, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 722, + 460, + 734 + ], + "score": 1.0, + "content": "averaged to produce the output. Full architecture and training details are in Appendix C.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41, + "bbox_fs": [ + 105, + 700, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 72, + 378, + 182 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 72, + 378, + 182 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 72, + 378, + 182 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 378, + 182 + ], + "score": 0.968, + "type": "image", + "image_path": "5770695687526489da2068203ed0e833315b117d7b1003431ea451379f1cd9f3.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 72, + 378, + 108.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 108.66666666666666, + 378, + 145.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 145.33333333333331, + 378, + 181.99999999999997 + ], + "spans": [], + "index": 4 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 191, + 378, + 211 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 190, + 379, + 202 + ], + "spans": [ + { + "bbox": [ + 105, + 190, + 379, + 202 + ], + "score": 1.0, + "content": "Figure 3: (Best seen in pdf) One sample episode each for grasping, pick-and-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 201, + 286, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 201, + 286, + 212 + ], + "score": 1.0, + "content": "place, and pushing. Time overlaid on each frame.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5 + } + ], + "index": 3.25 + }, + { + "type": "image", + "bbox": [ + 390, + 85, + 498, + 159 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 390, + 85, + 498, + 159 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 390, + 85, + 498, + 159 + ], + "spans": [ + { + "bbox": [ + 390, + 85, + 498, + 159 + ], + "score": 0.943, + "type": "image", + "image_path": "c276a2df0e0bfd87996b9ced2d4c7e08dda70fc8eb2ef52b070ed396f8e3d0f5.jpg" + } + ] + } + ], + "index": 2.5, + "virtual_lines": [ + { + "bbox": [ + 390, + 85, + 498, + 122.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 390, + 122.0, + 498, + 159.0 + ], + "spans": [], + "index": 3 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 387, + 160, + 505, + 210 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 387, + 160, + 504, + 171 + ], + "spans": [ + { + "bbox": [ + 387, + 160, + 495, + 171 + ], + "score": 1.0, + "content": "Figure 4: Forward prediction", + "type": "text" + }, + { + "bbox": [ + 495, + 160, + 504, + 170 + ], + "score": 0.81, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + } + ], + "index": 7 + }, + { + "bbox": [ + 387, + 170, + 505, + 181 + ], + "spans": [ + { + "bbox": [ + 387, + 170, + 505, + 181 + ], + "score": 1.0, + "content": "error for grasping. TAP methods", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 387, + 180, + 506, + 190 + ], + "spans": [ + { + "bbox": [ + 387, + 180, + 506, + 190 + ], + "score": 1.0, + "content": "(red) perform better than fixed-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 387, + 190, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 387, + 190, + 505, + 201 + ], + "score": 1.0, + "content": "time predictors over all time", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 386, + 200, + 411, + 213 + ], + "spans": [ + { + "bbox": [ + 386, + 200, + 411, + 213 + ], + "score": 1.0, + "content": "steps.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9 + } + ], + "index": 5.75 + }, + { + "type": "title", + "bbox": [ + 108, + 224, + 200, + 236 + ], + "lines": [ + { + "bbox": [ + 105, + 223, + 201, + 238 + ], + "spans": [ + { + "bbox": [ + 105, + 223, + 201, + 238 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 247, + 505, + 314 + ], + "lines": [ + { + "bbox": [ + 106, + 248, + 505, + 259 + ], + "spans": [ + { + "bbox": [ + 106, + 248, + 505, + 259 + ], + "score": 1.0, + "content": "We have proposed a time-agnostic prediction (TAP) paradigm that is different from the fixed-time", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 258, + 506, + 272 + ], + "spans": [ + { + "bbox": [ + 105, + 258, + 506, + 272 + ], + "score": 1.0, + "content": "paradigm followed in prior prediction work. In our experiments, we focus on comparing TAP against", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 269, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 104, + 269, + 505, + 282 + ], + "score": 1.0, + "content": "a representative fixed-time prediction model, keeping network architectures fixed. We use three", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 280, + 507, + 294 + ], + "spans": [ + { + "bbox": [ + 105, + 280, + 325, + 294 + ], + "score": 1.0, + "content": "simulated robot manipulation settings: object grasping (", + "type": "text" + }, + { + "bbox": [ + 325, + 281, + 341, + 291 + ], + "score": 0.41, + "content": "5 0 \\mathrm { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 280, + 447, + 294 + ], + "score": 1.0, + "content": "episodes), pick-and-place", + "type": "text" + }, + { + "bbox": [ + 447, + 281, + 464, + 291 + ], + "score": 0.44, + "content": "7 5 \\mathrm { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 280, + 507, + 294 + ], + "score": 1.0, + "content": "episodes),", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 291, + 505, + 303 + ], + "spans": [ + { + "bbox": [ + 106, + 291, + 505, + 303 + ], + "score": 1.0, + "content": "and multi-object pushing (55k episodes). Example episodes from each task are shown in Fig 3 (videos", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 302, + 398, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 145, + 316 + ], + "score": 1.0, + "content": "in Supp).", + "type": "text" + }, + { + "bbox": [ + 146, + 303, + 161, + 313 + ], + "score": 0.79, + "content": "5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 161, + 302, + 329, + 316 + ], + "score": 1.0, + "content": "of the data is set aside for testing. We use", + "type": "text" + }, + { + "bbox": [ + 330, + 303, + 364, + 313 + ], + "score": 0.89, + "content": "6 4 \\times 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 302, + 398, + 316 + ], + "score": 1.0, + "content": "images.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 107, + 319, + 505, + 374 + ], + "lines": [ + { + "bbox": [ + 106, + 320, + 505, + 332 + ], + "spans": [ + { + "bbox": [ + 106, + 320, + 505, + 332 + ], + "score": 1.0, + "content": "For grasping (15 frames per episode), the arm moves to a single object on a table, selects a grasp, and", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 329, + 506, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 506, + 343 + ], + "score": 1.0, + "content": "lifts it vertically. For pick-and-place (20 frames), the arm additionally places the lifted object at a new", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 340, + 506, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 506, + 354 + ], + "score": 1.0, + "content": "position before performing a random walk. For pushing (40 frames), two objects are initialized at", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 351, + 505, + 366 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 505, + 366 + ], + "score": 1.0, + "content": "random locations and pushed to random final positions. Object shapes and colors in all three settings", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 363, + 332, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 332, + 376 + ], + "score": 1.0, + "content": "are randomly generated. Fig 3 shows example episodes.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 106, + 379, + 505, + 468 + ], + "lines": [ + { + "bbox": [ + 105, + 379, + 506, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 379, + 506, + 392 + ], + "score": 1.0, + "content": "Forward prediction. First, we evaluate our approach for forward prediction on grasping. The first", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 389, + 506, + 404 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 506, + 404 + ], + "score": 1.0, + "content": "frame (“start”) is provided as input. We train fixed-time baselines (architecture same as ours, using", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 402, + 506, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 116, + 412 + ], + "score": 0.86, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 402, + 506, + 414 + ], + "score": 1.0, + "content": "and GAN losses same as MIN and GENMIN) that target predictions at exactly 0.25, 0.50, 0.75, 1.0", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 412, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 106, + 412, + 505, + 425 + ], + "score": 1.0, + "content": "fraction of the episode length (FIX0.25,. . . , FIX1.00). MIN and GENMIN are TAP with/without the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 423, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 207, + 436 + ], + "score": 1.0, + "content": "generalized minimum of", + "type": "text" + }, + { + "bbox": [ + 208, + 424, + 238, + 434 + ], + "score": 0.38, + "content": "{ \\tt S e c 3 . 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 423, + 505, + 436 + ], + "score": 1.0, + "content": ". For GENMIN, we evaluate different choices of the time preference", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 433, + 504, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 134, + 447 + ], + "score": 1.0, + "content": "vector", + "type": "text" + }, + { + "bbox": [ + 135, + 434, + 154, + 446 + ], + "score": 0.91, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 433, + 230, + 447 + ], + "score": 1.0, + "content": "(Sec 3.2). We set", + "type": "text" + }, + { + "bbox": [ + 231, + 434, + 303, + 446 + ], + "score": 0.92, + "content": "w ( t ) = \\beta + t / 1 5", + "type": "inline_equation" + }, + { + "bbox": [ + 303, + 433, + 496, + 447 + ], + "score": 1.0, + "content": ", so that our preference increases linearly from", + "type": "text" + }, + { + "bbox": [ + 496, + 435, + 504, + 446 + ], + "score": 0.82, + "content": "\\beta", + "type": "inline_equation" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 444, + 506, + 458 + ], + "spans": [ + { + "bbox": [ + 104, + 444, + 117, + 458 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 117, + 446, + 142, + 456 + ], + "score": 0.89, + "content": "\\beta + 1", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 444, + 173, + 458 + ], + "score": 1.0, + "content": ". Since", + "type": "text" + }, + { + "bbox": [ + 173, + 445, + 193, + 457 + ], + "score": 0.91, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 194, + 444, + 313, + 458 + ], + "score": 1.0, + "content": "applies multiplicatively, low", + "type": "text" + }, + { + "bbox": [ + 313, + 446, + 321, + 457 + ], + "score": 0.83, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 444, + 506, + 458 + ], + "score": 1.0, + "content": "corresponds to high disparity in preferences", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 456, + 498, + 469 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 109, + 469 + ], + "score": 0.0, + "content": "", + "type": "text" + }, + { + "bbox": [ + 110, + 457, + 140, + 468 + ], + "score": 0.89, + "content": "\\beta = \\infty", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 457, + 428, + 469 + ], + "score": 1.0, + "content": "reduces to MIN, i.e., no time preference). GENMIN2 is our approach with", + "type": "text" + }, + { + "bbox": [ + 429, + 456, + 454, + 468 + ], + "score": 0.91, + "content": "\\beta = 2", + "type": "inline_equation" + }, + { + "bbox": [ + 455, + 457, + 498, + 469 + ], + "score": 1.0, + "content": "and so on.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 106, + 473, + 505, + 539 + ], + "lines": [ + { + "bbox": [ + 106, + 473, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 505, + 486 + ], + "score": 1.0, + "content": "Fig 5 shows example predictions from all methods for the grasping task. In terms of visual quality", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 484, + 506, + 497 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 506, + 497 + ], + "score": 1.0, + "content": "of predictions and finding a semantically coherent bottleneck, GENMIN2, GENMIN4, and GENMIN7", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 495, + 506, + 508 + ], + "spans": [ + { + "bbox": [ + 104, + 495, + 506, + 508 + ], + "score": 1.0, + "content": "perform best—they reliably produce a grasp on the object while it is still on the table. With little or", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 506, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 505, + 519 + ], + "score": 1.0, + "content": "no time preferences, MIN and GENMIN10 produce images very close to the start, while GENMIN0.5", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 517, + 506, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 506, + 530 + ], + "score": 1.0, + "content": "places too high a value on predictions farther away, and produces blurry images of the object after", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 525, + 137, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 525, + 137, + 542 + ], + "score": 1.0, + "content": "lifting.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 34.5 + }, + { + "type": "text", + "bbox": [ + 106, + 544, + 505, + 644 + ], + "lines": [ + { + "bbox": [ + 106, + 545, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 408, + 556 + ], + "score": 1.0, + "content": "Quantitatively, for each method, we report the min and arg min index of the", + "type": "text" + }, + { + "bbox": [ + 408, + 545, + 418, + 556 + ], + "score": 0.87, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 418, + 545, + 505, + 556 + ], + "score": 1.0, + "content": "distance to all frames", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 555, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 192, + 569 + ], + "score": 1.0, + "content": "in the video, as “min", + "type": "text" + }, + { + "bbox": [ + 193, + 556, + 203, + 567 + ], + "score": 0.85, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 555, + 505, + 569 + ], + "score": 1.0, + "content": "err” and “match-step” (“which future ground truth frame is the prediction", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 567, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 505, + 579 + ], + "score": 1.0, + "content": "closest to?”). Fig 4 shows a scatter plot, where each dot or square is one model. TAP (various models", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 578, + 506, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 160, + 591 + ], + "score": 1.0, + "content": "with varying", + "type": "text" + }, + { + "bbox": [ + 161, + 578, + 168, + 590 + ], + "score": 0.75, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 578, + 506, + 591 + ], + "score": 1.0, + "content": ") produces an even larger variation in stepsizes than fixed-time methods explicitly", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 589, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 215, + 601 + ], + "score": 1.0, + "content": "targeting the entire video", + "type": "text" + }, + { + "bbox": [ + 216, + 589, + 248, + 599 + ], + "score": 0.48, + "content": "\\mathrm { ' } _ { \\mathrm { F I X 0 . 7 5 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 589, + 267, + 601 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 268, + 589, + 295, + 599 + ], + "score": 0.25, + "content": "\\mathrm { F I X } 1 . 0", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 589, + 506, + 601 + ], + "score": 1.0, + "content": "fall short of producing predictions at 0.75 and 1.0", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 599, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 106, + 599, + 506, + 613 + ], + "score": 1.0, + "content": "fraction of the episode length). TAP also produces higher quality predictions (lower error) over that", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 610, + 505, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 505, + 624 + ], + "score": 1.0, + "content": "entire range. From these quantitative and qualitative results, we see that TAP not only successfully", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 621, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 106, + 621, + 505, + 635 + ], + "score": 1.0, + "content": "encourages semantically coherent bottleneck predictions, it also produces higher quality predictions", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 633, + 326, + 645 + ], + "spans": [ + { + "bbox": [ + 106, + 633, + 326, + 645 + ], + "score": 1.0, + "content": "than fixed-time prediction over a range of time offsets.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 107, + 649, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "Intermediate frame prediction. Next, we evaluate our approaches for bidirectionally conditioned", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "prediction in all three settings. Initial and final frames are provided as input, and the method is trained", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 671, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 505, + 684 + ], + "score": 1.0, + "content": "to generate an intermediate frame. The FIX baseline now targets the middle frame. As before, MIN", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 360, + 694 + ], + "score": 1.0, + "content": "and GENMIN are our TAP models. The GENMIN time preference", + "type": "text" + }, + { + "bbox": [ + 361, + 682, + 380, + 694 + ], + "score": 0.92, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 681, + 505, + 694 + ], + "score": 1.0, + "content": "is bell-shaped and varies from", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 692, + 339, + 705 + ], + "spans": [ + { + "bbox": [ + 106, + 692, + 339, + 705 + ], + "score": 1.0, + "content": "2/3 at the ends to 1 at the middle frame (see Appendix E).", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 49 + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "Figs 6 and 9 show examples from the three settings. TAP approaches successfully discover interesting", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 719, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 505, + 734 + ], + "score": 1.0, + "content": "bottlenecks in each setting. For grasping (Fig 6 (left)), both MIN and GENMIN consistently produce", + "type": "text" + } + ], + "index": 53 + } + ], + "index": 52.5 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 310, + 762 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 72, + 378, + 182 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 72, + 378, + 182 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 72, + 378, + 182 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 378, + 182 + ], + "score": 0.968, + "type": "image", + "image_path": "5770695687526489da2068203ed0e833315b117d7b1003431ea451379f1cd9f3.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 72, + 378, + 108.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 108.66666666666666, + 378, + 145.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 145.33333333333331, + 378, + 181.99999999999997 + ], + "spans": [], + "index": 4 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 191, + 378, + 211 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 190, + 379, + 202 + ], + "spans": [ + { + "bbox": [ + 105, + 190, + 379, + 202 + ], + "score": 1.0, + "content": "Figure 3: (Best seen in pdf) One sample episode each for grasping, pick-and-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 201, + 286, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 201, + 286, + 212 + ], + "score": 1.0, + "content": "place, and pushing. Time overlaid on each frame.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5 + } + ], + "index": 3.25 + }, + { + "type": "image", + "bbox": [ + 390, + 85, + 498, + 159 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 390, + 85, + 498, + 159 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 390, + 85, + 498, + 159 + ], + "spans": [ + { + "bbox": [ + 390, + 85, + 498, + 159 + ], + "score": 0.943, + "type": "image", + "image_path": "c276a2df0e0bfd87996b9ced2d4c7e08dda70fc8eb2ef52b070ed396f8e3d0f5.jpg" + } + ] + } + ], + "index": 2.5, + "virtual_lines": [ + { + "bbox": [ + 390, + 85, + 498, + 122.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 390, + 122.0, + 498, + 159.0 + ], + "spans": [], + "index": 3 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 387, + 160, + 505, + 210 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 387, + 160, + 504, + 171 + ], + "spans": [ + { + "bbox": [ + 387, + 160, + 495, + 171 + ], + "score": 1.0, + "content": "Figure 4: Forward prediction", + "type": "text" + }, + { + "bbox": [ + 495, + 160, + 504, + 170 + ], + "score": 0.81, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + } + ], + "index": 7 + }, + { + "bbox": [ + 387, + 170, + 505, + 181 + ], + "spans": [ + { + "bbox": [ + 387, + 170, + 505, + 181 + ], + "score": 1.0, + "content": "error for grasping. TAP methods", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 387, + 180, + 506, + 190 + ], + "spans": [ + { + "bbox": [ + 387, + 180, + 506, + 190 + ], + "score": 1.0, + "content": "(red) perform better than fixed-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 387, + 190, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 387, + 190, + 505, + 201 + ], + "score": 1.0, + "content": "time predictors over all time", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 386, + 200, + 411, + 213 + ], + "spans": [ + { + "bbox": [ + 386, + 200, + 411, + 213 + ], + "score": 1.0, + "content": "steps.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9 + } + ], + "index": 5.75 + }, + { + "type": "title", + "bbox": [ + 108, + 224, + 200, + 236 + ], + "lines": [ + { + "bbox": [ + 105, + 223, + 201, + 238 + ], + "spans": [ + { + "bbox": [ + 105, + 223, + 201, + 238 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 247, + 505, + 314 + ], + "lines": [ + { + "bbox": [ + 106, + 248, + 505, + 259 + ], + "spans": [ + { + "bbox": [ + 106, + 248, + 505, + 259 + ], + "score": 1.0, + "content": "We have proposed a time-agnostic prediction (TAP) paradigm that is different from the fixed-time", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 258, + 506, + 272 + ], + "spans": [ + { + "bbox": [ + 105, + 258, + 506, + 272 + ], + "score": 1.0, + "content": "paradigm followed in prior prediction work. In our experiments, we focus on comparing TAP against", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 269, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 104, + 269, + 505, + 282 + ], + "score": 1.0, + "content": "a representative fixed-time prediction model, keeping network architectures fixed. We use three", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 280, + 507, + 294 + ], + "spans": [ + { + "bbox": [ + 105, + 280, + 325, + 294 + ], + "score": 1.0, + "content": "simulated robot manipulation settings: object grasping (", + "type": "text" + }, + { + "bbox": [ + 325, + 281, + 341, + 291 + ], + "score": 0.41, + "content": "5 0 \\mathrm { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 280, + 447, + 294 + ], + "score": 1.0, + "content": "episodes), pick-and-place", + "type": "text" + }, + { + "bbox": [ + 447, + 281, + 464, + 291 + ], + "score": 0.44, + "content": "7 5 \\mathrm { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 280, + 507, + 294 + ], + "score": 1.0, + "content": "episodes),", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 291, + 505, + 303 + ], + "spans": [ + { + "bbox": [ + 106, + 291, + 505, + 303 + ], + "score": 1.0, + "content": "and multi-object pushing (55k episodes). Example episodes from each task are shown in Fig 3 (videos", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 302, + 398, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 145, + 316 + ], + "score": 1.0, + "content": "in Supp).", + "type": "text" + }, + { + "bbox": [ + 146, + 303, + 161, + 313 + ], + "score": 0.79, + "content": "5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 161, + 302, + 329, + 316 + ], + "score": 1.0, + "content": "of the data is set aside for testing. We use", + "type": "text" + }, + { + "bbox": [ + 330, + 303, + 364, + 313 + ], + "score": 0.89, + "content": "6 4 \\times 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 302, + 398, + 316 + ], + "score": 1.0, + "content": "images.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15.5, + "bbox_fs": [ + 104, + 248, + 507, + 316 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 319, + 505, + 374 + ], + "lines": [ + { + "bbox": [ + 106, + 320, + 505, + 332 + ], + "spans": [ + { + "bbox": [ + 106, + 320, + 505, + 332 + ], + "score": 1.0, + "content": "For grasping (15 frames per episode), the arm moves to a single object on a table, selects a grasp, and", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 329, + 506, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 506, + 343 + ], + "score": 1.0, + "content": "lifts it vertically. For pick-and-place (20 frames), the arm additionally places the lifted object at a new", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 340, + 506, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 506, + 354 + ], + "score": 1.0, + "content": "position before performing a random walk. For pushing (40 frames), two objects are initialized at", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 351, + 505, + 366 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 505, + 366 + ], + "score": 1.0, + "content": "random locations and pushed to random final positions. Object shapes and colors in all three settings", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 363, + 332, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 332, + 376 + ], + "score": 1.0, + "content": "are randomly generated. Fig 3 shows example episodes.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 320, + 506, + 376 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 379, + 505, + 468 + ], + "lines": [ + { + "bbox": [ + 105, + 379, + 506, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 379, + 506, + 392 + ], + "score": 1.0, + "content": "Forward prediction. First, we evaluate our approach for forward prediction on grasping. The first", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 389, + 506, + 404 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 506, + 404 + ], + "score": 1.0, + "content": "frame (“start”) is provided as input. We train fixed-time baselines (architecture same as ours, using", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 402, + 506, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 116, + 412 + ], + "score": 0.86, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 402, + 506, + 414 + ], + "score": 1.0, + "content": "and GAN losses same as MIN and GENMIN) that target predictions at exactly 0.25, 0.50, 0.75, 1.0", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 412, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 106, + 412, + 505, + 425 + ], + "score": 1.0, + "content": "fraction of the episode length (FIX0.25,. . . , FIX1.00). MIN and GENMIN are TAP with/without the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 423, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 207, + 436 + ], + "score": 1.0, + "content": "generalized minimum of", + "type": "text" + }, + { + "bbox": [ + 208, + 424, + 238, + 434 + ], + "score": 0.38, + "content": "{ \\tt S e c 3 . 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 423, + 505, + 436 + ], + "score": 1.0, + "content": ". For GENMIN, we evaluate different choices of the time preference", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 433, + 504, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 134, + 447 + ], + "score": 1.0, + "content": "vector", + "type": "text" + }, + { + "bbox": [ + 135, + 434, + 154, + 446 + ], + "score": 0.91, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 433, + 230, + 447 + ], + "score": 1.0, + "content": "(Sec 3.2). We set", + "type": "text" + }, + { + "bbox": [ + 231, + 434, + 303, + 446 + ], + "score": 0.92, + "content": "w ( t ) = \\beta + t / 1 5", + "type": "inline_equation" + }, + { + "bbox": [ + 303, + 433, + 496, + 447 + ], + "score": 1.0, + "content": ", so that our preference increases linearly from", + "type": "text" + }, + { + "bbox": [ + 496, + 435, + 504, + 446 + ], + "score": 0.82, + "content": "\\beta", + "type": "inline_equation" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 444, + 506, + 458 + ], + "spans": [ + { + "bbox": [ + 104, + 444, + 117, + 458 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 117, + 446, + 142, + 456 + ], + "score": 0.89, + "content": "\\beta + 1", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 444, + 173, + 458 + ], + "score": 1.0, + "content": ". Since", + "type": "text" + }, + { + "bbox": [ + 173, + 445, + 193, + 457 + ], + "score": 0.91, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 194, + 444, + 313, + 458 + ], + "score": 1.0, + "content": "applies multiplicatively, low", + "type": "text" + }, + { + "bbox": [ + 313, + 446, + 321, + 457 + ], + "score": 0.83, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 444, + 506, + 458 + ], + "score": 1.0, + "content": "corresponds to high disparity in preferences", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 456, + 498, + 469 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 109, + 469 + ], + "score": 0.0, + "content": "", + "type": "text" + }, + { + "bbox": [ + 110, + 457, + 140, + 468 + ], + "score": 0.89, + "content": "\\beta = \\infty", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 457, + 428, + 469 + ], + "score": 1.0, + "content": "reduces to MIN, i.e., no time preference). GENMIN2 is our approach with", + "type": "text" + }, + { + "bbox": [ + 429, + 456, + 454, + 468 + ], + "score": 0.91, + "content": "\\beta = 2", + "type": "inline_equation" + }, + { + "bbox": [ + 455, + 457, + 498, + 469 + ], + "score": 1.0, + "content": "and so on.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 27.5, + "bbox_fs": [ + 104, + 379, + 506, + 469 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 473, + 505, + 539 + ], + "lines": [ + { + "bbox": [ + 106, + 473, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 505, + 486 + ], + "score": 1.0, + "content": "Fig 5 shows example predictions from all methods for the grasping task. In terms of visual quality", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 484, + 506, + 497 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 506, + 497 + ], + "score": 1.0, + "content": "of predictions and finding a semantically coherent bottleneck, GENMIN2, GENMIN4, and GENMIN7", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 495, + 506, + 508 + ], + "spans": [ + { + "bbox": [ + 104, + 495, + 506, + 508 + ], + "score": 1.0, + "content": "perform best—they reliably produce a grasp on the object while it is still on the table. With little or", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 506, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 505, + 519 + ], + "score": 1.0, + "content": "no time preferences, MIN and GENMIN10 produce images very close to the start, while GENMIN0.5", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 517, + 506, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 506, + 530 + ], + "score": 1.0, + "content": "places too high a value on predictions farther away, and produces blurry images of the object after", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 525, + 137, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 525, + 137, + 542 + ], + "score": 1.0, + "content": "lifting.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 34.5, + "bbox_fs": [ + 104, + 473, + 506, + 542 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 544, + 505, + 644 + ], + "lines": [ + { + "bbox": [ + 106, + 545, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 408, + 556 + ], + "score": 1.0, + "content": "Quantitatively, for each method, we report the min and arg min index of the", + "type": "text" + }, + { + "bbox": [ + 408, + 545, + 418, + 556 + ], + "score": 0.87, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 418, + 545, + 505, + 556 + ], + "score": 1.0, + "content": "distance to all frames", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 555, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 192, + 569 + ], + "score": 1.0, + "content": "in the video, as “min", + "type": "text" + }, + { + "bbox": [ + 193, + 556, + 203, + 567 + ], + "score": 0.85, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 555, + 505, + 569 + ], + "score": 1.0, + "content": "err” and “match-step” (“which future ground truth frame is the prediction", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 567, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 505, + 579 + ], + "score": 1.0, + "content": "closest to?”). Fig 4 shows a scatter plot, where each dot or square is one model. TAP (various models", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 578, + 506, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 160, + 591 + ], + "score": 1.0, + "content": "with varying", + "type": "text" + }, + { + "bbox": [ + 161, + 578, + 168, + 590 + ], + "score": 0.75, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 578, + 506, + 591 + ], + "score": 1.0, + "content": ") produces an even larger variation in stepsizes than fixed-time methods explicitly", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 589, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 215, + 601 + ], + "score": 1.0, + "content": "targeting the entire video", + "type": "text" + }, + { + "bbox": [ + 216, + 589, + 248, + 599 + ], + "score": 0.48, + "content": "\\mathrm { ' } _ { \\mathrm { F I X 0 . 7 5 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 589, + 267, + 601 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 268, + 589, + 295, + 599 + ], + "score": 0.25, + "content": "\\mathrm { F I X } 1 . 0", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 589, + 506, + 601 + ], + "score": 1.0, + "content": "fall short of producing predictions at 0.75 and 1.0", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 599, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 106, + 599, + 506, + 613 + ], + "score": 1.0, + "content": "fraction of the episode length). TAP also produces higher quality predictions (lower error) over that", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 610, + 505, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 505, + 624 + ], + "score": 1.0, + "content": "entire range. From these quantitative and qualitative results, we see that TAP not only successfully", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 621, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 106, + 621, + 505, + 635 + ], + "score": 1.0, + "content": "encourages semantically coherent bottleneck predictions, it also produces higher quality predictions", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 633, + 326, + 645 + ], + "spans": [ + { + "bbox": [ + 106, + 633, + 326, + 645 + ], + "score": 1.0, + "content": "than fixed-time prediction over a range of time offsets.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 42, + "bbox_fs": [ + 105, + 545, + 506, + 645 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 649, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "Intermediate frame prediction. Next, we evaluate our approaches for bidirectionally conditioned", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "prediction in all three settings. Initial and final frames are provided as input, and the method is trained", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 671, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 505, + 684 + ], + "score": 1.0, + "content": "to generate an intermediate frame. The FIX baseline now targets the middle frame. As before, MIN", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 360, + 694 + ], + "score": 1.0, + "content": "and GENMIN are our TAP models. The GENMIN time preference", + "type": "text" + }, + { + "bbox": [ + 361, + 682, + 380, + 694 + ], + "score": 0.92, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 681, + 505, + 694 + ], + "score": 1.0, + "content": "is bell-shaped and varies from", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 692, + 339, + 705 + ], + "spans": [ + { + "bbox": [ + 106, + 692, + 339, + 705 + ], + "score": 1.0, + "content": "2/3 at the ends to 1 at the middle frame (see Appendix E).", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 49, + "bbox_fs": [ + 105, + 648, + 505, + 705 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "Figs 6 and 9 show examples from the three settings. TAP approaches successfully discover interesting", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 719, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 505, + 734 + ], + "score": 1.0, + "content": "bottlenecks in each setting. For grasping (Fig 6 (left)), both MIN and GENMIN consistently produce", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 399, + 506, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 506, + 414 + ], + "score": 1.0, + "content": "clear images of the arm at the point at which it picks up the object. Pick-and-place (Fig 6, right) is", + "type": "text", + "cross_page": true + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 410, + 506, + 425 + ], + "spans": [ + { + "bbox": [ + 104, + 410, + 506, + 425 + ], + "score": 1.0, + "content": "harder because it is more temporally extended, and the goal image does not specify how to grasp", + "type": "text", + "cross_page": true + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 422, + 505, + 435 + ], + "spans": [ + { + "bbox": [ + 105, + 422, + 505, + 435 + ], + "score": 1.0, + "content": "the object. FIX struggles to produce any coherent predictions, but GENMIN once again identifies", + "type": "text", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 432, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 432, + 506, + 447 + ], + "score": 1.0, + "content": "bottlenecks reliably—in examples #3 and #1, it predicts the “pick” and the “place” respectively. For", + "type": "text", + "cross_page": true + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 444, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 505, + 456 + ], + "score": 1.0, + "content": "the pushing setting (Fig 9 (left)), GENMIN frequently produces images with one object moved and the", + "type": "text", + "cross_page": true + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 455, + 506, + 468 + ], + "spans": [ + { + "bbox": [ + 106, + 455, + 506, + 468 + ], + "score": 1.0, + "content": "other object fixed in place, which again is a semantically coherent bottleneck for this task. In row #1,", + "type": "text", + "cross_page": true + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 466, + 448, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 448, + 478 + ], + "score": 1.0, + "content": "it moves the correct object first to generate the subgoal, so that objects do not collide.", + "type": "text", + "cross_page": true + } + ], + "index": 19 + } + ], + "index": 52.5, + "bbox_fs": [ + 105, + 708, + 505, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 115, + 79, + 495, + 202 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 115, + 79, + 495, + 202 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 115, + 79, + 495, + 202 + ], + "spans": [ + { + "bbox": [ + 115, + 79, + 495, + 202 + ], + "score": 0.933, + "type": "image", + "image_path": "f86ef90a00ab7b85808ffe17668e41b8c711bf42aeb798ea3b554ada01459605.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 115, + 79, + 495, + 120.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 115, + 120.0, + 495, + 161.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 115, + 161.0, + 495, + 202.0 + ], + "spans": [], + "index": 2 + } + ] + } + ], + "index": 1 + }, + { + "type": "image", + "bbox": [ + 108, + 243, + 502, + 345 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 107, + 212, + 503, + 242 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 211, + 505, + 224 + ], + "spans": [ + { + "bbox": [ + 105, + 211, + 505, + 224 + ], + "score": 1.0, + "content": "Figure 5: (Best seen in pdf) Forward prediction results on grasping comparing fixed-time predictors and our", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 222, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 222, + 505, + 234 + ], + "score": 1.0, + "content": "approach. Each row is a separate example. First column is the input. Thereafter, each column corresponds to the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 232, + 376, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 376, + 244 + ], + "score": 1.0, + "content": "output of a different model per the column title. More in Appendix Fig 17.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + }, + { + "type": "image_body", + "bbox": [ + 108, + 243, + 502, + 345 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 243, + 502, + 345 + ], + "spans": [ + { + "bbox": [ + 108, + 243, + 502, + 345 + ], + "score": 0.954, + "type": "image", + "image_path": "e5accb667c317aea1ebb4ab176afeda30572430c2be8e635f7851878016d9e41.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 108, + 243, + 502, + 277.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 108, + 277.0, + 502, + 311.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 108, + 311.0, + 502, + 345.0 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 355, + 505, + 396 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 355, + 506, + 367 + ], + "spans": [ + { + "bbox": [ + 106, + 355, + 506, + 367 + ], + "score": 1.0, + "content": "Figure 6: (Best seen in pdf) Bidirectional prediction results comparing fixed-time prediction and our approach.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 366, + 505, + 376 + ], + "spans": [ + { + "bbox": [ + 106, + 366, + 505, + 376 + ], + "score": 1.0, + "content": "(Left) Grasping results. First two columns are inputs (start and goal). Thereafter, each column corresponds to", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 374, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 505, + 387 + ], + "score": 1.0, + "content": "the output of a different model per the column title. “match” is the ground truth image closest to the GENMIN", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 384, + 496, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 496, + 398 + ], + "score": 1.0, + "content": "prediction. More in Appendix Fig 13. (Right) Similar results for pick-and-place. More in Appendix Fig 14.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 106, + 400, + 505, + 478 + ], + "lines": [ + { + "bbox": [ + 105, + 399, + 506, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 506, + 414 + ], + "score": 1.0, + "content": "clear images of the arm at the point at which it picks up the object. Pick-and-place (Fig 6, right) is", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 410, + 506, + 425 + ], + "spans": [ + { + "bbox": [ + 104, + 410, + 506, + 425 + ], + "score": 1.0, + "content": "harder because it is more temporally extended, and the goal image does not specify how to grasp", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 422, + 505, + 435 + ], + "spans": [ + { + "bbox": [ + 105, + 422, + 505, + 435 + ], + "score": 1.0, + "content": "the object. FIX struggles to produce any coherent predictions, but GENMIN once again identifies", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 432, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 432, + 506, + 447 + ], + "score": 1.0, + "content": "bottlenecks reliably—in examples #3 and #1, it predicts the “pick” and the “place” respectively. For", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 444, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 505, + 456 + ], + "score": 1.0, + "content": "the pushing setting (Fig 9 (left)), GENMIN frequently produces images with one object moved and the", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 455, + 506, + 468 + ], + "spans": [ + { + "bbox": [ + 106, + 455, + 506, + 468 + ], + "score": 1.0, + "content": "other object fixed in place, which again is a semantically coherent bottleneck for this task. In row #1,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 466, + 448, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 448, + 478 + ], + "score": 1.0, + "content": "it moves the correct object first to generate the subgoal, so that objects do not collide.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 483, + 505, + 604 + ], + "lines": [ + { + "bbox": [ + 105, + 482, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 494, + 495 + ], + "score": 1.0, + "content": "Table 1 shows quantitative results over the full test set. As in forward prediction, we report min", + "type": "text" + }, + { + "bbox": [ + 495, + 483, + 505, + 494 + ], + "score": 0.85, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 494, + 505, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 505, + 506 + ], + "score": 1.0, + "content": "error and the best-matching frame index (“match-step”) for all methods. MIN and GENMIN consistently", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 505, + 506, + 518 + ], + "spans": [ + { + "bbox": [ + 104, + 505, + 506, + 518 + ], + "score": 1.0, + "content": "yield higher quality predictions (lower error) than FIX at similar times on average. As an example,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 516, + 506, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 227, + 528 + ], + "score": 1.0, + "content": "GENMIN reduces FIX errors by", + "type": "text" + }, + { + "bbox": [ + 227, + 516, + 247, + 527 + ], + "score": 0.84, + "content": "21 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 247, + 516, + 250, + 528 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 251, + 516, + 278, + 527 + ], + "score": 0.86, + "content": "2 6 . 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 516, + 298, + 528 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 299, + 516, + 326, + 527 + ], + "score": 0.87, + "content": "5 3 . 2 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 327, + 516, + 506, + 528 + ], + "score": 1.0, + "content": "on the three tasks—these are consistent and", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 526, + 506, + 541 + ], + "spans": [ + { + "bbox": [ + 104, + 526, + 506, + 541 + ], + "score": 1.0, + "content": "large gains that increase with increasing task complexity/duration. Additionally, while all foregoing", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 538, + 506, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 506, + 550 + ], + "score": 1.0, + "content": "results were reported without the CVAE approach of Sec 3.4, Table 1 shows results for GENMIN+VAE,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 549, + 505, + 561 + ], + "spans": [ + { + "bbox": [ + 106, + 549, + 505, + 561 + ], + "score": 1.0, + "content": "and Fig 9 shows example predictions for pick-and-place. In our models, individual stochastic", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 560, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 209, + 572 + ], + "score": 1.0, + "content": "predictions from GENMIN", + "type": "text" + }, + { + "bbox": [ + 209, + 562, + 216, + 570 + ], + "score": 0.47, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 560, + 297, + 572 + ], + "score": 1.0, + "content": "VAE produce higher", + "type": "text" + }, + { + "bbox": [ + 297, + 560, + 307, + 571 + ], + "score": 0.87, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 560, + 505, + 572 + ], + "score": 1.0, + "content": "errors than GENMIN. However, the CVAE helps", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 570, + 506, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 506, + 583 + ], + "score": 1.0, + "content": "capture meaningful sources of stochasticity at the bottlenecks—in Fig 9 (right), it produces different", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 582, + 506, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 506, + 594 + ], + "score": 1.0, + "content": "grasp configurations to pick up the object in each case. To measure this, we evaluate the best of 100", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 248, + 605 + ], + "score": 1.0, + "content": "stochastic predictions from GENMIN", + "type": "text" + }, + { + "bbox": [ + 248, + 595, + 254, + 603 + ], + "score": 0.42, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 592, + 347, + 605 + ], + "score": 1.0, + "content": "VAE in Table 1 (GENMIN", + "type": "text" + }, + { + "bbox": [ + 348, + 595, + 354, + 602 + ], + "score": 0.31, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 354, + 592, + 505, + 605 + ], + "score": 1.0, + "content": "VAE BEST-OF-100). On pick-and-place", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 25 + }, + { + "type": "table", + "bbox": [ + 108, + 623, + 496, + 707 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 108, + 623, + 496, + 707 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 623, + 496, + 707 + ], + "spans": [ + { + "bbox": [ + 108, + 623, + 496, + 707 + ], + "score": 0.976, + "html": "
Setting→ Method↓Grasping (T=15 steps) min lierrmatch-step/TPick-and-place (T=20 steps) min l1 errmatch-step/TPushing (T=30 steps) min l1 errmatch-step/T
fix0.01530.51±0.170.03660.53±0.240.07220.36±0.19
MIN (ours)0.01040.49±0.180.02560.41±0.300.03650.35±0.22
GENMIN (ours)0.01210.45±0.160.02690.42±0.230.03380.36±0.19
GENMIN W/O GAN (Ours)0.01170.45±0.160.02350.46±0.250.04110.37±0.19
GENMIN + VAE (Ours)0.01560.47±0.180.04320.31±0.240.04470.37±0.21
GENMIN + VAE BEST-OF-10O (Ours)0.0121-0.0196-0.0236-
", + "type": "table", + "image_path": "1084ec4c5632b944c87b5533346157f4ba859696b63576a0934c34e863408242.jpg" + } + ] + } + ], + "index": 32, + "virtual_lines": [ + { + "bbox": [ + 108, + 623, + 496, + 651.0 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 108, + 651.0, + 496, + 679.0 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 108, + 679.0, + 496, + 707.0 + ], + "spans": [], + "index": 33 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 107, + 715, + 504, + 746 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 714, + 505, + 728 + ], + "spans": [ + { + "bbox": [ + 104, + 714, + 505, + 728 + ], + "score": 1.0, + "content": "Table 1: Bidirectional frame prediction performance on: grasping, pick-and-place, and two-object pushing.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 725, + 505, + 737 + ], + "spans": [ + { + "bbox": [ + 105, + 725, + 148, + 737 + ], + "score": 1.0, + "content": "Lower min", + "type": "text" + }, + { + "bbox": [ + 149, + 726, + 158, + 735 + ], + "score": 0.85, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 158, + 725, + 421, + 737 + ], + "score": 1.0, + "content": "err is better. match-step denotes which times are being predicted, out of", + "type": "text" + }, + { + "bbox": [ + 421, + 726, + 429, + 735 + ], + "score": 0.74, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 725, + 505, + 737 + ], + "score": 1.0, + "content": "steps. It is clear that", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 736, + 428, + 746 + ], + "spans": [ + { + "bbox": [ + 105, + 736, + 428, + 746 + ], + "score": 1.0, + "content": "TAP methods make better predictions than fixed-time prediction at the same time offsets.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35 + } + ], + "index": 33.5 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 115, + 79, + 495, + 202 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 115, + 79, + 495, + 202 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 115, + 79, + 495, + 202 + ], + "spans": [ + { + "bbox": [ + 115, + 79, + 495, + 202 + ], + "score": 0.933, + "type": "image", + "image_path": "f86ef90a00ab7b85808ffe17668e41b8c711bf42aeb798ea3b554ada01459605.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 115, + 79, + 495, + 120.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 115, + 120.0, + 495, + 161.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 115, + 161.0, + 495, + 202.0 + ], + "spans": [], + "index": 2 + } + ] + } + ], + "index": 1 + }, + { + "type": "image", + "bbox": [ + 108, + 243, + 502, + 345 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 107, + 212, + 503, + 242 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 211, + 505, + 224 + ], + "spans": [ + { + "bbox": [ + 105, + 211, + 505, + 224 + ], + "score": 1.0, + "content": "Figure 5: (Best seen in pdf) Forward prediction results on grasping comparing fixed-time predictors and our", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 222, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 222, + 505, + 234 + ], + "score": 1.0, + "content": "approach. Each row is a separate example. First column is the input. Thereafter, each column corresponds to the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 232, + 376, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 376, + 244 + ], + "score": 1.0, + "content": "output of a different model per the column title. More in Appendix Fig 17.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + }, + { + "type": "image_body", + "bbox": [ + 108, + 243, + 502, + 345 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 243, + 502, + 345 + ], + "spans": [ + { + "bbox": [ + 108, + 243, + 502, + 345 + ], + "score": 0.954, + "type": "image", + "image_path": "e5accb667c317aea1ebb4ab176afeda30572430c2be8e635f7851878016d9e41.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 108, + 243, + 502, + 277.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 108, + 277.0, + 502, + 311.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 108, + 311.0, + 502, + 345.0 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 355, + 505, + 396 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 355, + 506, + 367 + ], + "spans": [ + { + "bbox": [ + 106, + 355, + 506, + 367 + ], + "score": 1.0, + "content": "Figure 6: (Best seen in pdf) Bidirectional prediction results comparing fixed-time prediction and our approach.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 366, + 505, + 376 + ], + "spans": [ + { + "bbox": [ + 106, + 366, + 505, + 376 + ], + "score": 1.0, + "content": "(Left) Grasping results. First two columns are inputs (start and goal). Thereafter, each column corresponds to", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 374, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 505, + 387 + ], + "score": 1.0, + "content": "the output of a different model per the column title. “match” is the ground truth image closest to the GENMIN", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 384, + 496, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 496, + 398 + ], + "score": 1.0, + "content": "prediction. More in Appendix Fig 13. (Right) Similar results for pick-and-place. More in Appendix Fig 14.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 106, + 400, + 505, + 478 + ], + "lines": [], + "index": 16, + "bbox_fs": [ + 104, + 399, + 506, + 478 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 483, + 505, + 604 + ], + "lines": [ + { + "bbox": [ + 105, + 482, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 494, + 495 + ], + "score": 1.0, + "content": "Table 1 shows quantitative results over the full test set. As in forward prediction, we report min", + "type": "text" + }, + { + "bbox": [ + 495, + 483, + 505, + 494 + ], + "score": 0.85, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 494, + 505, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 505, + 506 + ], + "score": 1.0, + "content": "error and the best-matching frame index (“match-step”) for all methods. MIN and GENMIN consistently", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 505, + 506, + 518 + ], + "spans": [ + { + "bbox": [ + 104, + 505, + 506, + 518 + ], + "score": 1.0, + "content": "yield higher quality predictions (lower error) than FIX at similar times on average. As an example,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 516, + 506, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 227, + 528 + ], + "score": 1.0, + "content": "GENMIN reduces FIX errors by", + "type": "text" + }, + { + "bbox": [ + 227, + 516, + 247, + 527 + ], + "score": 0.84, + "content": "21 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 247, + 516, + 250, + 528 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 251, + 516, + 278, + 527 + ], + "score": 0.86, + "content": "2 6 . 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 516, + 298, + 528 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 299, + 516, + 326, + 527 + ], + "score": 0.87, + "content": "5 3 . 2 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 327, + 516, + 506, + 528 + ], + "score": 1.0, + "content": "on the three tasks—these are consistent and", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 526, + 506, + 541 + ], + "spans": [ + { + "bbox": [ + 104, + 526, + 506, + 541 + ], + "score": 1.0, + "content": "large gains that increase with increasing task complexity/duration. Additionally, while all foregoing", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 538, + 506, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 506, + 550 + ], + "score": 1.0, + "content": "results were reported without the CVAE approach of Sec 3.4, Table 1 shows results for GENMIN+VAE,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 549, + 505, + 561 + ], + "spans": [ + { + "bbox": [ + 106, + 549, + 505, + 561 + ], + "score": 1.0, + "content": "and Fig 9 shows example predictions for pick-and-place. In our models, individual stochastic", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 560, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 209, + 572 + ], + "score": 1.0, + "content": "predictions from GENMIN", + "type": "text" + }, + { + "bbox": [ + 209, + 562, + 216, + 570 + ], + "score": 0.47, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 560, + 297, + 572 + ], + "score": 1.0, + "content": "VAE produce higher", + "type": "text" + }, + { + "bbox": [ + 297, + 560, + 307, + 571 + ], + "score": 0.87, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 560, + 505, + 572 + ], + "score": 1.0, + "content": "errors than GENMIN. However, the CVAE helps", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 570, + 506, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 506, + 583 + ], + "score": 1.0, + "content": "capture meaningful sources of stochasticity at the bottlenecks—in Fig 9 (right), it produces different", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 582, + 506, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 506, + 594 + ], + "score": 1.0, + "content": "grasp configurations to pick up the object in each case. To measure this, we evaluate the best of 100", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 248, + 605 + ], + "score": 1.0, + "content": "stochastic predictions from GENMIN", + "type": "text" + }, + { + "bbox": [ + 248, + 595, + 254, + 603 + ], + "score": 0.42, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 592, + 347, + 605 + ], + "score": 1.0, + "content": "VAE in Table 1 (GENMIN", + "type": "text" + }, + { + "bbox": [ + 348, + 595, + 354, + 602 + ], + "score": 0.31, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 354, + 592, + 505, + 605 + ], + "score": 1.0, + "content": "VAE BEST-OF-100). On pick-and-place", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 253, + 506, + 265 + ], + "spans": [ + { + "bbox": [ + 106, + 253, + 506, + 265 + ], + "score": 1.0, + "content": "and pushing, the best VAE results are significantly better than any of the deterministic methods.", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 468, + 276 + ], + "score": 1.0, + "content": "Table 1 also shows results for our method without the GAN (GENMIN W/O GAN)—while its", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 468, + 264, + 478, + 275 + ], + "score": 0.88, + "content": "\\ell _ { 1 }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 478, + 263, + 505, + 276 + ], + "score": 1.0, + "content": "errors", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 275, + 321, + 288 + ], + "spans": [ + { + "bbox": [ + 106, + 275, + 321, + 288 + ], + "score": 1.0, + "content": "are comparable, we observed a drop in visual quality.", + "type": "text", + "cross_page": true + } + ], + "index": 9 + } + ], + "index": 25, + "bbox_fs": [ + 104, + 482, + 506, + 605 + ] + }, + { + "type": "table", + "bbox": [ + 108, + 623, + 496, + 707 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 108, + 623, + 496, + 707 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 623, + 496, + 707 + ], + "spans": [ + { + "bbox": [ + 108, + 623, + 496, + 707 + ], + "score": 0.976, + "html": "
Setting→ Method↓Grasping (T=15 steps) min lierrmatch-step/TPick-and-place (T=20 steps) min l1 errmatch-step/TPushing (T=30 steps) min l1 errmatch-step/T
fix0.01530.51±0.170.03660.53±0.240.07220.36±0.19
MIN (ours)0.01040.49±0.180.02560.41±0.300.03650.35±0.22
GENMIN (ours)0.01210.45±0.160.02690.42±0.230.03380.36±0.19
GENMIN W/O GAN (Ours)0.01170.45±0.160.02350.46±0.250.04110.37±0.19
GENMIN + VAE (Ours)0.01560.47±0.180.04320.31±0.240.04470.37±0.21
GENMIN + VAE BEST-OF-10O (Ours)0.0121-0.0196-0.0236-
", + "type": "table", + "image_path": "1084ec4c5632b944c87b5533346157f4ba859696b63576a0934c34e863408242.jpg" + } + ] + } + ], + "index": 32, + "virtual_lines": [ + { + "bbox": [ + 108, + 623, + 496, + 651.0 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 108, + 651.0, + 496, + 679.0 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 108, + 679.0, + 496, + 707.0 + ], + "spans": [], + "index": 33 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 107, + 715, + 504, + 746 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 714, + 505, + 728 + ], + "spans": [ + { + "bbox": [ + 104, + 714, + 505, + 728 + ], + "score": 1.0, + "content": "Table 1: Bidirectional frame prediction performance on: grasping, pick-and-place, and two-object pushing.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 725, + 505, + 737 + ], + "spans": [ + { + "bbox": [ + 105, + 725, + 148, + 737 + ], + "score": 1.0, + "content": "Lower min", + "type": "text" + }, + { + "bbox": [ + 149, + 726, + 158, + 735 + ], + "score": 0.85, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 158, + 725, + 421, + 737 + ], + "score": 1.0, + "content": "err is better. match-step denotes which times are being predicted, out of", + "type": "text" + }, + { + "bbox": [ + 421, + 726, + 429, + 735 + ], + "score": 0.74, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 725, + 505, + 737 + ], + "score": 1.0, + "content": "steps. It is clear that", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 736, + 428, + 746 + ], + "spans": [ + { + "bbox": [ + 105, + 736, + 428, + 746 + ], + "score": 1.0, + "content": "TAP methods make better predictions than fixed-time prediction at the same time offsets.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35 + } + ], + "index": 33.5 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 108, + 79, + 502, + 187 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 79, + 502, + 187 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 79, + 502, + 187 + ], + "spans": [ + { + "bbox": [ + 108, + 79, + 502, + 187 + ], + "score": 0.96, + "type": "image", + "image_path": "08ead4e71ea153e3db3ca86982af8338fef990eac09998525a0fdc8907203658.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 108, + 79, + 502, + 115.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 108, + 115.0, + 502, + 151.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 108, + 151.0, + 502, + 187.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 197, + 506, + 237 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 197, + 505, + 209 + ], + "spans": [ + { + "bbox": [ + 106, + 197, + 505, + 209 + ], + "score": 1.0, + "content": "Figure 9: (Best seen in pdf) (Left) Bidirectional prediction results on two-object pushing. More in Appendix", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 207, + 506, + 218 + ], + "spans": [ + { + "bbox": [ + 105, + 207, + 506, + 218 + ], + "score": 1.0, + "content": "Fig 15. (Right) When used with a VAE (Sec 3.4), our approach captures residual stochasticity at the bottleneck.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 216, + 506, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 302, + 228 + ], + "score": 1.0, + "content": "In these results from the pick-and-place task, GENMIN", + "type": "text" + }, + { + "bbox": [ + 303, + 219, + 309, + 226 + ], + "score": 0.37, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 216, + 506, + 228 + ], + "score": 1.0, + "content": "VAE produces images that are all of the arm in contact", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 226, + 474, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 226, + 474, + 239 + ], + "score": 1.0, + "content": "with the object on the table, but at different points on the object, and with different arm/gripper poses.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "text", + "bbox": [ + 106, + 253, + 506, + 286 + ], + "lines": [ + { + "bbox": [ + 106, + 253, + 506, + 265 + ], + "spans": [ + { + "bbox": [ + 106, + 253, + 506, + 265 + ], + "score": 1.0, + "content": "and pushing, the best VAE results are significantly better than any of the deterministic methods.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 468, + 276 + ], + "score": 1.0, + "content": "Table 1 also shows results for our method without the GAN (GENMIN W/O GAN)—while its", + "type": "text" + }, + { + "bbox": [ + 468, + 264, + 478, + 275 + ], + "score": 0.88, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 263, + 505, + 276 + ], + "score": 1.0, + "content": "errors", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 275, + 321, + 288 + ], + "spans": [ + { + "bbox": [ + 106, + 275, + 321, + 288 + ], + "score": 1.0, + "content": "are comparable, we observed a drop in visual quality.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 292, + 304, + 412 + ], + "lines": [ + { + "bbox": [ + 106, + 291, + 304, + 304 + ], + "spans": [ + { + "bbox": [ + 106, + 291, + 167, + 304 + ], + "score": 1.0, + "content": "As indicated in", + "type": "text" + }, + { + "bbox": [ + 167, + 292, + 197, + 303 + ], + "score": 0.25, + "content": "{ \\mathrm { S e c } } 3 . 1", + "type": "inline_equation" + }, + { + "bbox": [ + 197, + 291, + 304, + 304 + ], + "score": 1.0, + "content": "and Eq 3, TAP may also be", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 303, + 305, + 315 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 305, + 315 + ], + "score": 1.0, + "content": "applied recursively. Fig 7 compares consecutive", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 314, + 305, + 326 + ], + "spans": [ + { + "bbox": [ + 106, + 314, + 305, + 326 + ], + "score": 1.0, + "content": "subgoals for the pick-and-place task produced by", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 325, + 306, + 335 + ], + "spans": [ + { + "bbox": [ + 106, + 325, + 306, + 335 + ], + "score": 1.0, + "content": "recursive TAP versus a recursive fixed-time model.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 335, + 306, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 172, + 348 + ], + "score": 1.0, + "content": "Recursion level", + "type": "text" + }, + { + "bbox": [ + 172, + 336, + 198, + 346 + ], + "score": 0.92, + "content": "r = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 335, + 306, + 348 + ], + "score": 1.0, + "content": "refers to the first subgoal,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 347, + 305, + 358 + ], + "spans": [ + { + "bbox": [ + 106, + 347, + 124, + 358 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 124, + 347, + 150, + 357 + ], + "score": 0.89, + "content": "r = 2", + "type": "inline_equation" + }, + { + "bbox": [ + 150, + 347, + 305, + 358 + ], + "score": 1.0, + "content": "refers to the subgoal generated when", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 357, + 305, + 370 + ], + "spans": [ + { + "bbox": [ + 106, + 357, + 305, + 370 + ], + "score": 1.0, + "content": "the first subgoal is provided as the goal input (start", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 369, + 305, + 381 + ], + "spans": [ + { + "bbox": [ + 106, + 369, + 305, + 381 + ], + "score": 1.0, + "content": "input is unchanged). In example #1, FIX struggles", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 379, + 306, + 391 + ], + "spans": [ + { + "bbox": [ + 106, + 379, + 306, + 391 + ], + "score": 1.0, + "content": "while “ours” identifies the “place” bottleneck at", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 107, + 390, + 306, + 402 + ], + "spans": [ + { + "bbox": [ + 107, + 391, + 131, + 401 + ], + "score": 0.88, + "content": "r = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 390, + 306, + 402 + ], + "score": 1.0, + "content": ", and subsequently the “pick” botleneck at", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 402, + 135, + 412 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 131, + 412 + ], + "score": 0.84, + "content": "r = 2", + "type": "inline_equation" + }, + { + "bbox": [ + 131, + 402, + 135, + 412 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 15 + }, + { + "type": "image", + "bbox": [ + 312, + 291, + 504, + 371 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 312, + 291, + 504, + 371 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 312, + 291, + 504, + 371 + ], + "spans": [ + { + "bbox": [ + 312, + 291, + 504, + 371 + ], + "score": 0.969, + "type": "image", + "image_path": "fe2aa8133a51dbd41e95dc77f0fc36f12af4aaa53458e7768be0fa33c485273a.jpg" + } + ] + } + ], + "index": 23.5, + "virtual_lines": [ + { + "bbox": [ + 312, + 291, + 504, + 304.3333333333333 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 312, + 304.3333333333333, + 504, + 317.66666666666663 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 312, + 317.66666666666663, + 504, + 330.99999999999994 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 312, + 330.99999999999994, + 504, + 344.33333333333326 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 312, + 344.33333333333326, + 504, + 357.6666666666666 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 312, + 357.6666666666666, + 504, + 370.9999999999999 + ], + "spans": [], + "index": 26 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 312, + 376, + 505, + 397 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 312, + 376, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 312, + 376, + 505, + 387 + ], + "score": 1.0, + "content": "Figure 7: Recursive bidirectional prediction on pick-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 312, + 387, + 481, + 397 + ], + "spans": [ + { + "bbox": [ + 312, + 387, + 352, + 397 + ], + "score": 1.0, + "content": "and-place.", + "type": "text" + }, + { + "bbox": [ + 352, + 387, + 375, + 396 + ], + "score": 0.88, + "content": "r = 2", + "type": "inline_equation" + }, + { + "bbox": [ + 375, + 387, + 454, + 397 + ], + "score": 1.0, + "content": "is earlier in time than", + "type": "text" + }, + { + "bbox": [ + 455, + 387, + 477, + 396 + ], + "score": 0.88, + "content": "r = 2", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 387, + 481, + 397 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 107, + 418, + 354, + 550 + ], + "lines": [ + { + "bbox": [ + 105, + 417, + 356, + 431 + ], + "spans": [ + { + "bbox": [ + 105, + 417, + 356, + 431 + ], + "score": 1.0, + "content": "Finally, we test on “BAIR pushing” (Ebert et al., 2017), a", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 429, + 355, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 355, + 442 + ], + "score": 1.0, + "content": "real-world dataset that is commonly used in visual prediction", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 440, + 355, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 355, + 452 + ], + "score": 1.0, + "content": "tasks. The data consists of 30-frame clips of random motions", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 451, + 355, + 463 + ], + "spans": [ + { + "bbox": [ + 106, + 451, + 355, + 463 + ], + "score": 1.0, + "content": "of a Sawyer arm tabletop. While this dataset does not have", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 462, + 355, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 296, + 474 + ], + "score": 1.0, + "content": "natural bottlenecks like in grasping, TAP (min", + "type": "text" + }, + { + "bbox": [ + 296, + 462, + 306, + 473 + ], + "score": 0.84, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 462, + 355, + 474 + ], + "score": 1.0, + "content": "error 0.046", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 473, + 356, + 485 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 356, + 485 + ], + "score": 1.0, + "content": "at match-step 15.42) still performs better than FIX (0.059 at", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 484, + 356, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 356, + 496 + ], + "score": 1.0, + "content": "15.29). Qualitatively, as Fig 8 shows, even though BAIR push-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 495, + 356, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 356, + 507 + ], + "score": 1.0, + "content": "ing contains incoherent random arm motions, TAP consistently", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 506, + 356, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 356, + 518 + ], + "score": 1.0, + "content": "produces predictions that plausibly lie on the path from start to", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 517, + 355, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 355, + 529 + ], + "score": 1.0, + "content": "goal image. In example #1, given a start and goal image with", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 528, + 355, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 355, + 540 + ], + "score": 1.0, + "content": "one object displaced, “ours” correctly moves the arm to the", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 538, + 309, + 552 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 309, + 552 + ], + "score": 1.0, + "content": "object before displacement, whereas FIX struggles.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 34.5 + }, + { + "type": "image", + "bbox": [ + 362, + 418, + 504, + 495 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 362, + 418, + 504, + 495 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 362, + 418, + 504, + 495 + ], + "spans": [ + { + "bbox": [ + 362, + 418, + 504, + 495 + ], + "score": 0.965, + "type": "image", + "image_path": "9385c328efd3ef9d40d2aebb6da428efee79f90d0d1504ea5d2217964752ce67.jpg" + } + ] + } + ], + "index": 41.5, + "virtual_lines": [ + { + "bbox": [ + 362, + 418, + 504, + 456.5 + ], + "spans": [], + "index": 41 + }, + { + "bbox": [ + 362, + 456.5, + 504, + 495.0 + ], + "spans": [], + "index": 42 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 362, + 502, + 505, + 542 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 361, + 501, + 506, + 513 + ], + "spans": [ + { + "bbox": [ + 361, + 501, + 506, + 513 + ], + "score": 1.0, + "content": "Figure 8: Bidirectional prediction re-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 362, + 512, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 362, + 512, + 505, + 523 + ], + "score": 1.0, + "content": "sults on BAIR pushing data. The first", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 362, + 522, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 362, + 522, + 505, + 533 + ], + "score": 1.0, + "content": "two columns are the inputs, and the next", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 361, + 532, + 495, + 542 + ], + "spans": [ + { + "bbox": [ + 361, + 532, + 495, + 542 + ], + "score": 1.0, + "content": "two correspond to FIX and GENMIN.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 44.5 + } + ], + "index": 43.0 + }, + { + "type": "text", + "bbox": [ + 107, + 567, + 396, + 687 + ], + "lines": [ + { + "bbox": [ + 106, + 567, + 396, + 579 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 396, + 579 + ], + "score": 1.0, + "content": "Bottleneck discovery frequency. We have thus far relied on qualitative", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 578, + 396, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 396, + 590 + ], + "score": 1.0, + "content": "results to assess how often our approach finds coherent bottlenecks. For", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 589, + 397, + 602 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 397, + 602 + ], + "score": 1.0, + "content": "pushing, we test bottleneck discovery frequency more quantitatively. We", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 598, + 397, + 614 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 397, + 614 + ], + "score": 1.0, + "content": "make the reasonable assumption that bottlenecks in 2-object pushing", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 611, + 398, + 623 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 398, + 623 + ], + "score": 1.0, + "content": "correspond to states where one object is pushed and the other is in place.", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 621, + 397, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 397, + 634 + ], + "score": 1.0, + "content": "Our metric exploits knowledge of true object positions at start and goal", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 106, + 633, + 396, + 644 + ], + "spans": [ + { + "bbox": [ + 106, + 633, + 396, + 644 + ], + "score": 1.0, + "content": "states. First, for this evaluation, we restrict both GENMIN and FIX to", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 105, + 644, + 397, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 397, + 656 + ], + "score": 1.0, + "content": "synthesize predictions purely by warping and masking inputs. Thus, we", + "type": "text" + } + ], + "index": 55 + }, + { + "bbox": [ + 105, + 655, + 397, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 397, + 667 + ], + "score": 1.0, + "content": "can track where the pixels at ground truth object locations in start and", + "type": "text" + } + ], + "index": 57 + }, + { + "bbox": [ + 105, + 666, + 397, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 397, + 678 + ], + "score": 1.0, + "content": "goal images end up in the prediction, i.e., where did each object move?", + "type": "text" + } + ], + "index": 59 + }, + { + "bbox": [ + 105, + 676, + 396, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 396, + 689 + ], + "score": 1.0, + "content": "We then compute a score that may be thresholded to detect when only", + "type": "text" + } + ], + "index": 60 + } + ], + "index": 53 + }, + { + "type": "image", + "bbox": [ + 406, + 570, + 500, + 647 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 406, + 570, + 500, + 647 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 406, + 570, + 500, + 647 + ], + "spans": [ + { + "bbox": [ + 406, + 570, + 500, + 647 + ], + "score": 0.958, + "type": "image", + "image_path": "c98be0a524e6a6ba7b94ce1b7a36d75a2305e1440f91fbf772d0f3efa5ba64f2.jpg" + } + ] + } + ], + "index": 53.5, + "virtual_lines": [ + { + "bbox": [ + 406, + 570, + 500, + 608.5 + ], + "spans": [], + "index": 51 + }, + { + "bbox": [ + 406, + 608.5, + 500, + 647.0 + ], + "spans": [], + "index": 56 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 403, + 659, + 505, + 679 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 403, + 659, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 403, + 659, + 506, + 669 + ], + "score": 1.0, + "content": "Figure 10: Bottleneck fre-", + "type": "text" + } + ], + "index": 58 + }, + { + "bbox": [ + 403, + 670, + 501, + 679 + ], + "spans": [ + { + "bbox": [ + 403, + 670, + 501, + 679 + ], + "score": 1.0, + "content": "quency vs. score threshold", + "type": "text" + } + ], + "index": 61 + } + ], + "index": 59.5 + } + ], + "index": 56.5 + }, + { + "type": "text", + "bbox": [ + 107, + 689, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 701 + ], + "score": 1.0, + "content": "one object moves (details in Appendix F). As an intuitive example, suppose that the two objects are", + "type": "text" + } + ], + "index": 62 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 159, + 711 + ], + "score": 1.0, + "content": "displaced by", + "type": "text" + }, + { + "bbox": [ + 160, + 699, + 186, + 709 + ], + "score": 0.68, + "content": "1 0 \\mathrm { c m }", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 699, + 203, + 711 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 204, + 699, + 230, + 709 + ], + "score": 0.65, + "content": "1 5 \\mathrm { { c m } }", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "respectively between start and goal frames. Suppose further that our", + "type": "text" + } + ], + "index": 63 + }, + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "predictor predicts the start frame as its output. Then its distance score would be computed to be 10", + "type": "text" + } + ], + "index": 64 + }, + { + "bbox": [ + 105, + 720, + 507, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 256, + 733 + ], + "score": 1.0, + "content": "cm. For all values of threshold below", + "type": "text" + }, + { + "bbox": [ + 257, + 721, + 282, + 731 + ], + "score": 0.67, + "content": "1 0 \\mathrm { c m }", + "type": "inline_equation" + }, + { + "bbox": [ + 282, + 720, + 507, + 733 + ], + "score": 1.0, + "content": ", this would be counted as a bottleneck discovery failure.", + "type": "text" + } + ], + "index": 65 + } + ], + "index": 63.5 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 300, + 750, + 309, + 761 + ], + "spans": [ + { + "bbox": [ + 300, + 750, + 309, + 761 + ], + "score": 1.0, + "content": "8", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 108, + 79, + 502, + 187 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 79, + 502, + 187 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 79, + 502, + 187 + ], + "spans": [ + { + "bbox": [ + 108, + 79, + 502, + 187 + ], + "score": 0.96, + "type": "image", + "image_path": "08ead4e71ea153e3db3ca86982af8338fef990eac09998525a0fdc8907203658.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 108, + 79, + 502, + 115.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 108, + 115.0, + 502, + 151.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 108, + 151.0, + 502, + 187.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 197, + 506, + 237 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 197, + 505, + 209 + ], + "spans": [ + { + "bbox": [ + 106, + 197, + 505, + 209 + ], + "score": 1.0, + "content": "Figure 9: (Best seen in pdf) (Left) Bidirectional prediction results on two-object pushing. More in Appendix", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 207, + 506, + 218 + ], + "spans": [ + { + "bbox": [ + 105, + 207, + 506, + 218 + ], + "score": 1.0, + "content": "Fig 15. (Right) When used with a VAE (Sec 3.4), our approach captures residual stochasticity at the bottleneck.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 216, + 506, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 302, + 228 + ], + "score": 1.0, + "content": "In these results from the pick-and-place task, GENMIN", + "type": "text" + }, + { + "bbox": [ + 303, + 219, + 309, + 226 + ], + "score": 0.37, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 216, + 506, + 228 + ], + "score": 1.0, + "content": "VAE produces images that are all of the arm in contact", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 226, + 474, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 226, + 474, + 239 + ], + "score": 1.0, + "content": "with the object on the table, but at different points on the object, and with different arm/gripper poses.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "text", + "bbox": [ + 106, + 253, + 506, + 286 + ], + "lines": [], + "index": 8, + "bbox_fs": [ + 105, + 253, + 506, + 288 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 292, + 304, + 412 + ], + "lines": [ + { + "bbox": [ + 106, + 291, + 304, + 304 + ], + "spans": [ + { + "bbox": [ + 106, + 291, + 167, + 304 + ], + "score": 1.0, + "content": "As indicated in", + "type": "text" + }, + { + "bbox": [ + 167, + 292, + 197, + 303 + ], + "score": 0.25, + "content": "{ \\mathrm { S e c } } 3 . 1", + "type": "inline_equation" + }, + { + "bbox": [ + 197, + 291, + 304, + 304 + ], + "score": 1.0, + "content": "and Eq 3, TAP may also be", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 303, + 305, + 315 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 305, + 315 + ], + "score": 1.0, + "content": "applied recursively. Fig 7 compares consecutive", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 314, + 305, + 326 + ], + "spans": [ + { + "bbox": [ + 106, + 314, + 305, + 326 + ], + "score": 1.0, + "content": "subgoals for the pick-and-place task produced by", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 325, + 306, + 335 + ], + "spans": [ + { + "bbox": [ + 106, + 325, + 306, + 335 + ], + "score": 1.0, + "content": "recursive TAP versus a recursive fixed-time model.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 335, + 306, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 172, + 348 + ], + "score": 1.0, + "content": "Recursion level", + "type": "text" + }, + { + "bbox": [ + 172, + 336, + 198, + 346 + ], + "score": 0.92, + "content": "r = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 335, + 306, + 348 + ], + "score": 1.0, + "content": "refers to the first subgoal,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 347, + 305, + 358 + ], + "spans": [ + { + "bbox": [ + 106, + 347, + 124, + 358 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 124, + 347, + 150, + 357 + ], + "score": 0.89, + "content": "r = 2", + "type": "inline_equation" + }, + { + "bbox": [ + 150, + 347, + 305, + 358 + ], + "score": 1.0, + "content": "refers to the subgoal generated when", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 357, + 305, + 370 + ], + "spans": [ + { + "bbox": [ + 106, + 357, + 305, + 370 + ], + "score": 1.0, + "content": "the first subgoal is provided as the goal input (start", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 369, + 305, + 381 + ], + "spans": [ + { + "bbox": [ + 106, + 369, + 305, + 381 + ], + "score": 1.0, + "content": "input is unchanged). In example #1, FIX struggles", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 379, + 306, + 391 + ], + "spans": [ + { + "bbox": [ + 106, + 379, + 306, + 391 + ], + "score": 1.0, + "content": "while “ours” identifies the “place” bottleneck at", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 107, + 390, + 306, + 402 + ], + "spans": [ + { + "bbox": [ + 107, + 391, + 131, + 401 + ], + "score": 0.88, + "content": "r = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 390, + 306, + 402 + ], + "score": 1.0, + "content": ", and subsequently the “pick” botleneck at", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 402, + 135, + 412 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 131, + 412 + ], + "score": 0.84, + "content": "r = 2", + "type": "inline_equation" + }, + { + "bbox": [ + 131, + 402, + 135, + 412 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 291, + 306, + 412 + ] + }, + { + "type": "image", + "bbox": [ + 312, + 291, + 504, + 371 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 312, + 291, + 504, + 371 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 312, + 291, + 504, + 371 + ], + "spans": [ + { + "bbox": [ + 312, + 291, + 504, + 371 + ], + "score": 0.969, + "type": "image", + "image_path": "fe2aa8133a51dbd41e95dc77f0fc36f12af4aaa53458e7768be0fa33c485273a.jpg" + } + ] + } + ], + "index": 23.5, + "virtual_lines": [ + { + "bbox": [ + 312, + 291, + 504, + 304.3333333333333 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 312, + 304.3333333333333, + 504, + 317.66666666666663 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 312, + 317.66666666666663, + 504, + 330.99999999999994 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 312, + 330.99999999999994, + 504, + 344.33333333333326 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 312, + 344.33333333333326, + 504, + 357.6666666666666 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 312, + 357.6666666666666, + 504, + 370.9999999999999 + ], + "spans": [], + "index": 26 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 312, + 376, + 505, + 397 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 312, + 376, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 312, + 376, + 505, + 387 + ], + "score": 1.0, + "content": "Figure 7: Recursive bidirectional prediction on pick-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 312, + 387, + 481, + 397 + ], + "spans": [ + { + "bbox": [ + 312, + 387, + 352, + 397 + ], + "score": 1.0, + "content": "and-place.", + "type": "text" + }, + { + "bbox": [ + 352, + 387, + 375, + 396 + ], + "score": 0.88, + "content": "r = 2", + "type": "inline_equation" + }, + { + "bbox": [ + 375, + 387, + 454, + 397 + ], + "score": 1.0, + "content": "is earlier in time than", + "type": "text" + }, + { + "bbox": [ + 455, + 387, + 477, + 396 + ], + "score": 0.88, + "content": "r = 2", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 387, + 481, + 397 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 107, + 418, + 354, + 550 + ], + "lines": [ + { + "bbox": [ + 105, + 417, + 356, + 431 + ], + "spans": [ + { + "bbox": [ + 105, + 417, + 356, + 431 + ], + "score": 1.0, + "content": "Finally, we test on “BAIR pushing” (Ebert et al., 2017), a", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 429, + 355, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 355, + 442 + ], + "score": 1.0, + "content": "real-world dataset that is commonly used in visual prediction", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 440, + 355, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 355, + 452 + ], + "score": 1.0, + "content": "tasks. The data consists of 30-frame clips of random motions", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 451, + 355, + 463 + ], + "spans": [ + { + "bbox": [ + 106, + 451, + 355, + 463 + ], + "score": 1.0, + "content": "of a Sawyer arm tabletop. While this dataset does not have", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 462, + 355, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 296, + 474 + ], + "score": 1.0, + "content": "natural bottlenecks like in grasping, TAP (min", + "type": "text" + }, + { + "bbox": [ + 296, + 462, + 306, + 473 + ], + "score": 0.84, + "content": "\\ell _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 462, + 355, + 474 + ], + "score": 1.0, + "content": "error 0.046", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 473, + 356, + 485 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 356, + 485 + ], + "score": 1.0, + "content": "at match-step 15.42) still performs better than FIX (0.059 at", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 484, + 356, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 356, + 496 + ], + "score": 1.0, + "content": "15.29). Qualitatively, as Fig 8 shows, even though BAIR push-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 495, + 356, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 356, + 507 + ], + "score": 1.0, + "content": "ing contains incoherent random arm motions, TAP consistently", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 506, + 356, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 356, + 518 + ], + "score": 1.0, + "content": "produces predictions that plausibly lie on the path from start to", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 517, + 355, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 355, + 529 + ], + "score": 1.0, + "content": "goal image. In example #1, given a start and goal image with", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 528, + 355, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 355, + 540 + ], + "score": 1.0, + "content": "one object displaced, “ours” correctly moves the arm to the", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 538, + 309, + 552 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 309, + 552 + ], + "score": 1.0, + "content": "object before displacement, whereas FIX struggles.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 417, + 356, + 552 + ] + }, + { + "type": "image", + "bbox": [ + 362, + 418, + 504, + 495 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 362, + 418, + 504, + 495 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 362, + 418, + 504, + 495 + ], + "spans": [ + { + "bbox": [ + 362, + 418, + 504, + 495 + ], + "score": 0.965, + "type": "image", + "image_path": "9385c328efd3ef9d40d2aebb6da428efee79f90d0d1504ea5d2217964752ce67.jpg" + } + ] + } + ], + "index": 41.5, + "virtual_lines": [ + { + "bbox": [ + 362, + 418, + 504, + 456.5 + ], + "spans": [], + "index": 41 + }, + { + "bbox": [ + 362, + 456.5, + 504, + 495.0 + ], + "spans": [], + "index": 42 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 362, + 502, + 505, + 542 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 361, + 501, + 506, + 513 + ], + "spans": [ + { + "bbox": [ + 361, + 501, + 506, + 513 + ], + "score": 1.0, + "content": "Figure 8: Bidirectional prediction re-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 362, + 512, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 362, + 512, + 505, + 523 + ], + "score": 1.0, + "content": "sults on BAIR pushing data. The first", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 362, + 522, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 362, + 522, + 505, + 533 + ], + "score": 1.0, + "content": "two columns are the inputs, and the next", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 361, + 532, + 495, + 542 + ], + "spans": [ + { + "bbox": [ + 361, + 532, + 495, + 542 + ], + "score": 1.0, + "content": "two correspond to FIX and GENMIN.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 44.5 + } + ], + "index": 43.0 + }, + { + "type": "text", + "bbox": [ + 107, + 567, + 396, + 687 + ], + "lines": [ + { + "bbox": [ + 106, + 567, + 396, + 579 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 396, + 579 + ], + "score": 1.0, + "content": "Bottleneck discovery frequency. We have thus far relied on qualitative", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 578, + 396, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 396, + 590 + ], + "score": 1.0, + "content": "results to assess how often our approach finds coherent bottlenecks. For", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 589, + 397, + 602 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 397, + 602 + ], + "score": 1.0, + "content": "pushing, we test bottleneck discovery frequency more quantitatively. We", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 598, + 397, + 614 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 397, + 614 + ], + "score": 1.0, + "content": "make the reasonable assumption that bottlenecks in 2-object pushing", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 611, + 398, + 623 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 398, + 623 + ], + "score": 1.0, + "content": "correspond to states where one object is pushed and the other is in place.", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 621, + 397, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 397, + 634 + ], + "score": 1.0, + "content": "Our metric exploits knowledge of true object positions at start and goal", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 106, + 633, + 396, + 644 + ], + "spans": [ + { + "bbox": [ + 106, + 633, + 396, + 644 + ], + "score": 1.0, + "content": "states. First, for this evaluation, we restrict both GENMIN and FIX to", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 105, + 644, + 397, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 397, + 656 + ], + "score": 1.0, + "content": "synthesize predictions purely by warping and masking inputs. Thus, we", + "type": "text" + } + ], + "index": 55 + }, + { + "bbox": [ + 105, + 655, + 397, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 397, + 667 + ], + "score": 1.0, + "content": "can track where the pixels at ground truth object locations in start and", + "type": "text" + } + ], + "index": 57 + }, + { + "bbox": [ + 105, + 666, + 397, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 397, + 678 + ], + "score": 1.0, + "content": "goal images end up in the prediction, i.e., where did each object move?", + "type": "text" + } + ], + "index": 59 + }, + { + "bbox": [ + 105, + 676, + 396, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 396, + 689 + ], + "score": 1.0, + "content": "We then compute a score that may be thresholded to detect when only", + "type": "text" + } + ], + "index": 60 + }, + { + "bbox": [ + 105, + 687, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 701 + ], + "score": 1.0, + "content": "one object moves (details in Appendix F). As an intuitive example, suppose that the two objects are", + "type": "text" + } + ], + "index": 62 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 159, + 711 + ], + "score": 1.0, + "content": "displaced by", + "type": "text" + }, + { + "bbox": [ + 160, + 699, + 186, + 709 + ], + "score": 0.68, + "content": "1 0 \\mathrm { c m }", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 699, + 203, + 711 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 204, + 699, + 230, + 709 + ], + "score": 0.65, + "content": "1 5 \\mathrm { { c m } }", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "respectively between start and goal frames. Suppose further that our", + "type": "text" + } + ], + "index": 63 + }, + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "predictor predicts the start frame as its output. Then its distance score would be computed to be 10", + "type": "text" + } + ], + "index": 64 + }, + { + "bbox": [ + 105, + 720, + 507, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 256, + 733 + ], + "score": 1.0, + "content": "cm. For all values of threshold below", + "type": "text" + }, + { + "bbox": [ + 257, + 721, + 282, + 731 + ], + "score": 0.67, + "content": "1 0 \\mathrm { c m }", + "type": "inline_equation" + }, + { + "bbox": [ + 282, + 720, + 507, + 733 + ], + "score": 1.0, + "content": ", this would be counted as a bottleneck discovery failure.", + "type": "text" + } + ], + "index": 65 + } + ], + "index": 53, + "bbox_fs": [ + 105, + 567, + 398, + 689 + ] + }, + { + "type": "image", + "bbox": [ + 406, + 570, + 500, + 647 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 406, + 570, + 500, + 647 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 406, + 570, + 500, + 647 + ], + "spans": [ + { + "bbox": [ + 406, + 570, + 500, + 647 + ], + "score": 0.958, + "type": "image", + "image_path": "c98be0a524e6a6ba7b94ce1b7a36d75a2305e1440f91fbf772d0f3efa5ba64f2.jpg" + } + ] + } + ], + "index": 53.5, + "virtual_lines": [ + { + "bbox": [ + 406, + 570, + 500, + 608.5 + ], + "spans": [], + "index": 51 + }, + { + "bbox": [ + 406, + 608.5, + 500, + 647.0 + ], + "spans": [], + "index": 56 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 403, + 659, + 505, + 679 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 403, + 659, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 403, + 659, + 506, + 669 + ], + "score": 1.0, + "content": "Figure 10: Bottleneck fre-", + "type": "text" + } + ], + "index": 58 + }, + { + "bbox": [ + 403, + 670, + 501, + 679 + ], + "spans": [ + { + "bbox": [ + 403, + 670, + 501, + 679 + ], + "score": 1.0, + "content": "quency vs. score threshold", + "type": "text" + } + ], + "index": 61 + } + ], + "index": 59.5 + } + ], + "index": 56.5 + }, + { + "type": "text", + "bbox": [ + 107, + 689, + 505, + 732 + ], + "lines": [], + "index": 63.5, + "bbox_fs": [ + 105, + 687, + 507, + 733 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 390, + 95 + ], + "score": 1.0, + "content": "As Fig 10 shows, GENMIN predicts bottlenecks much more frequently", + "type": "text" + }, + { + "bbox": [ + 391, + 83, + 419, + 93 + ], + "score": 0.88, + "content": "\\sim 6 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 82, + 506, + 95 + ], + "score": 1.0, + "content": "of the time) than FIX.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 107 + ], + "score": 1.0, + "content": "As hypothesized, our time-agnostic approach does indeed identify and latch on to low-uncertainty", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 238, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 238, + 116 + ], + "score": 1.0, + "content": "states to improve its predictions.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 139, + 375, + 228 + ], + "lines": [ + { + "bbox": [ + 106, + 139, + 376, + 151 + ], + "spans": [ + { + "bbox": [ + 106, + 139, + 376, + 151 + ], + "score": 1.0, + "content": "Hierarchical planning evaluation. Finally, we discuss experi-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 150, + 376, + 162 + ], + "spans": [ + { + "bbox": [ + 106, + 150, + 376, + 162 + ], + "score": 1.0, + "content": "ments directly evaluating our intermediate predictions as visual", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 161, + 376, + 173 + ], + "spans": [ + { + "bbox": [ + 106, + 161, + 376, + 173 + ], + "score": 1.0, + "content": "subgoals for hierarchical planning for pushing tasks. A forward", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 172, + 376, + 184 + ], + "spans": [ + { + "bbox": [ + 106, + 172, + 376, + 184 + ], + "score": 1.0, + "content": "Visual MPC planner (Ebert et al., 2017) accepts the subgoal object", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 183, + 376, + 195 + ], + "spans": [ + { + "bbox": [ + 105, + 183, + 376, + 195 + ], + "score": 1.0, + "content": "positions (computed as above for evaluating bottlenecks). Start and", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 194, + 376, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 194, + 376, + 206 + ], + "score": 1.0, + "content": "goal object positions are also known. Internally, Visual MPC makes", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 205, + 376, + 217 + ], + "spans": [ + { + "bbox": [ + 106, + 205, + 376, + 217 + ], + "score": 1.0, + "content": "action-conditioned fixed-time forward predictions of future object", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 216, + 376, + 228 + ], + "spans": [ + { + "bbox": [ + 106, + 216, + 376, + 228 + ], + "score": 1.0, + "content": "positions to find an action sequence that reaches the subgoal object", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6.5 + }, + { + "type": "table", + "bbox": [ + 385, + 141, + 504, + 189 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 385, + 141, + 504, + 189 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 385, + 141, + 504, + 189 + ], + "spans": [ + { + "bbox": [ + 385, + 141, + 504, + 189 + ], + "score": 0.971, + "html": "
2-object3-object
direct12.9±0.615.8±0.6
FIX12.5±0.517.6±0.6
GENMIN11.9±0.612.9±0.7
", + "type": "table", + "image_path": "91aa2871f959f5c4caab3f23c69cc737c597c3a5f2593fa436f4e4dcd82aec90.jpg" + } + ] + } + ], + "index": 11.5, + "virtual_lines": [ + { + "bbox": [ + 385, + 141, + 504, + 165.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 385, + 165.0, + 504, + 189.0 + ], + "spans": [], + "index": 12 + } + ] + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 384, + 197, + 505, + 217 + ], + "lines": [ + { + "bbox": [ + 382, + 196, + 506, + 208 + ], + "spans": [ + { + "bbox": [ + 382, + 196, + 506, + 208 + ], + "score": 1.0, + "content": "Table 2: Multi-object pushing er-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 383, + 207, + 430, + 218 + ], + "spans": [ + { + "bbox": [ + 383, + 207, + 430, + 218 + ], + "score": 1.0, + "content": "rors (in cm).", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 110, + 227, + 487, + 238 + ], + "lines": [ + { + "bbox": [ + 108, + 225, + 489, + 240 + ], + "spans": [ + { + "bbox": [ + 108, + 225, + 489, + 240 + ], + "score": 1.0, + "content": "positions, with a planning horizon of 15. Additional implementation details are in Appendix G.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 106, + 244, + 505, + 354 + ], + "lines": [ + { + "bbox": [ + 106, + 243, + 505, + 256 + ], + "spans": [ + { + "bbox": [ + 106, + 243, + 505, + 256 + ], + "score": 1.0, + "content": "Given start and goal images, our model produces a subgoal. Visual MPC plans towards this subgoal", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 254, + 506, + 268 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 506, + 268 + ], + "score": 1.0, + "content": "for half the episode length, then switches to the final goal. We compare this scheme against (i)", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 265, + 505, + 278 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 505, + 278 + ], + "score": 1.0, + "content": "“direct”: planning directly towards the final goal for the entire episode length, and (ii) FIX: subgoals", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 276, + 506, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 506, + 289 + ], + "score": 1.0, + "content": "from a center-frame predictor. The error measure is the mean of object distances to goal states (lower", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 288, + 506, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 407, + 300 + ], + "score": 1.0, + "content": "is better). As an upper bound, single-object pushing with the planner yields", + "type": "text" + }, + { + "bbox": [ + 408, + 288, + 434, + 298 + ], + "score": 0.85, + "content": "{ \\sim } 5 \\mathrm { c m }", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 288, + 506, + 300 + ], + "score": 1.0, + "content": "error. Results for", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 299, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 106, + 299, + 505, + 312 + ], + "score": 1.0, + "content": "two-object and three-object pushing are shown in Table 2. GENMIN does best on both, but especially", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 309, + 506, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 506, + 322 + ], + "score": 1.0, + "content": "on the more complex three-object task. Since Visual MPC has thus far been demonstrated to work", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 321, + 506, + 333 + ], + "spans": [ + { + "bbox": [ + 106, + 321, + 506, + 333 + ], + "score": 1.0, + "content": "only on pushing tasks, our hierarchical planning evaluation is also limited to this task. Going forward,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 331, + 505, + 344 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 505, + 344 + ], + "score": 1.0, + "content": "we plan to adapt Visual MPC to allow testing TAP on more complex temporally extended tasks like", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 342, + 444, + 355 + ], + "spans": [ + { + "bbox": [ + 106, + 342, + 444, + 355 + ], + "score": 1.0, + "content": "block-stacking, where direct planning breaks down and subgoals offer greater value.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 20.5 + }, + { + "type": "title", + "bbox": [ + 108, + 381, + 201, + 393 + ], + "lines": [ + { + "bbox": [ + 104, + 378, + 203, + 397 + ], + "spans": [ + { + "bbox": [ + 104, + 378, + 203, + 397 + ], + "score": 1.0, + "content": "5 CONCLUSIONS", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 412, + 505, + 522 + ], + "lines": [ + { + "bbox": [ + 105, + 412, + 506, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 506, + 425 + ], + "score": 1.0, + "content": "The standard paradigm for prediction tasks demands that a predictor not only make good predictions,", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 424, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 106, + 424, + 505, + 437 + ], + "score": 1.0, + "content": "but that it make them on a set schedule. We have argued for redefining the prediction task so that the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 435, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 106, + 435, + 505, + 447 + ], + "score": 1.0, + "content": "predictor need only care that its prediction occur at some time, rather than that it occur at a specific", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 446, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 446, + 505, + 459 + ], + "score": 1.0, + "content": "scheduled time. We define this time-agnostic prediction task and propose novel technical approaches", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 457, + 506, + 469 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 506, + 469 + ], + "score": 1.0, + "content": "to solve it, that require relatively small changes to standard prediction methods. Our results show that", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 468, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 106, + 468, + 505, + 480 + ], + "score": 1.0, + "content": "reframing prediction objectives in this way yields higher quality predictions that are also semantically", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 479, + 504, + 491 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 504, + 491 + ], + "score": 1.0, + "content": "coherent—unattached to a rigid schedule of regularly specified timestamps, model predictions instead", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 489, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 505, + 502 + ], + "score": 1.0, + "content": "naturally attach to specific semantic “bottleneck” events, like a grasp. In our preliminary experiments", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 501, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 106, + 501, + 505, + 513 + ], + "score": 1.0, + "content": "with a hierarchical visual planner, our results suggest that such predictions could serve as useful", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 511, + 219, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 219, + 524 + ], + "score": 1.0, + "content": "subgoals for complex tasks.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 31.5 + }, + { + "type": "text", + "bbox": [ + 107, + 528, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 106, + 529, + 504, + 540 + ], + "spans": [ + { + "bbox": [ + 106, + 529, + 504, + 540 + ], + "score": 1.0, + "content": "In future work, we would like to address some limitations of our TAP formulation, of which we will", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 539, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 505, + 551 + ], + "score": 1.0, + "content": "mention two here. First, TAP currently benefits not only from selecting which times to predict, but", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 550, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 505, + 563 + ], + "score": 1.0, + "content": "also from not having to provide timestamps attached to its predictions. We would like to study: could", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 561, + 505, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 505, + 575 + ], + "score": 1.0, + "content": "we retain the benefits of time-agnostic prediction while also providing timestamps for when each", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 572, + 504, + 584 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 504, + 584 + ], + "score": 1.0, + "content": "predicted state will occur? Second, our current TAP formulation may not generalize to prediction", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 583, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 506, + 596 + ], + "score": 1.0, + "content": "problems in all settings of interest. As an example, for videos of juggling or waving, which involve", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 594, + 506, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 506, + 606 + ], + "score": 1.0, + "content": "repeated frames, TAP might collapse to predicting the input state repeatedly. We would like to", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 604, + 505, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 411, + 619 + ], + "score": 1.0, + "content": "investigate more general TAP formulations: for example, rather than choosing", + "type": "text" + }, + { + "bbox": [ + 412, + 605, + 422, + 617 + ], + "score": 0.89, + "content": "\\mathcal { E } _ { t } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 422, + 604, + 505, + 619 + ], + "score": 1.0, + "content": "in Eq 5 to encourage", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 616, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 505, + 629 + ], + "score": 1.0, + "content": "predicting farther away times, we could conceivably penalize predictions that look too similar to the", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 627, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 505, + 640 + ], + "score": 1.0, + "content": "input context frames. More broadly, we believe that our results thus far hold great promise for many", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 637, + 507, + 652 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 507, + 652 + ], + "score": 1.0, + "content": "applications of prediction including hierarchical planning and model-based reinforcement learning,", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 649, + 289, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 289, + 661 + ], + "score": 1.0, + "content": "and we hope to build further on these results.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 42.5 + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 666, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 505, + 677 + ], + "score": 1.0, + "content": "Acknowledgements. We thank Alex Lee and Chelsea Finn for helpful discussions and Sudeep Dasari", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "for help with the simulation framework and for generating the simulated data used in this work. We", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "thank Kate Rakelly, Kyle Hsu, and Allan Jabri for feedback on early drafts. This work was supported", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "by Berkeley DeepDrive, NSF IIS-1614653, NSF IIS-1633310, and an Office of Naval Research", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 708, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 506, + 723 + ], + "score": 1.0, + "content": "Young Investigator Program award. The NVIDIA DGX-1 used for this research was donated by the", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 720, + 198, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 198, + 734 + ], + "score": 1.0, + "content": "NVIDIA Corporation.", + "type": "text" + } + ], + "index": 54 + } + ], + "index": 51.5 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 390, + 95 + ], + "score": 1.0, + "content": "As Fig 10 shows, GENMIN predicts bottlenecks much more frequently", + "type": "text" + }, + { + "bbox": [ + 391, + 83, + 419, + 93 + ], + "score": 0.88, + "content": "\\sim 6 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 82, + 506, + 95 + ], + "score": 1.0, + "content": "of the time) than FIX.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 107 + ], + "score": 1.0, + "content": "As hypothesized, our time-agnostic approach does indeed identify and latch on to low-uncertainty", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 238, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 238, + 116 + ], + "score": 1.0, + "content": "states to improve its predictions.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 105, + 82, + 506, + 116 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 139, + 375, + 228 + ], + "lines": [ + { + "bbox": [ + 106, + 139, + 376, + 151 + ], + "spans": [ + { + "bbox": [ + 106, + 139, + 376, + 151 + ], + "score": 1.0, + "content": "Hierarchical planning evaluation. Finally, we discuss experi-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 150, + 376, + 162 + ], + "spans": [ + { + "bbox": [ + 106, + 150, + 376, + 162 + ], + "score": 1.0, + "content": "ments directly evaluating our intermediate predictions as visual", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 161, + 376, + 173 + ], + "spans": [ + { + "bbox": [ + 106, + 161, + 376, + 173 + ], + "score": 1.0, + "content": "subgoals for hierarchical planning for pushing tasks. A forward", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 172, + 376, + 184 + ], + "spans": [ + { + "bbox": [ + 106, + 172, + 376, + 184 + ], + "score": 1.0, + "content": "Visual MPC planner (Ebert et al., 2017) accepts the subgoal object", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 183, + 376, + 195 + ], + "spans": [ + { + "bbox": [ + 105, + 183, + 376, + 195 + ], + "score": 1.0, + "content": "positions (computed as above for evaluating bottlenecks). Start and", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 194, + 376, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 194, + 376, + 206 + ], + "score": 1.0, + "content": "goal object positions are also known. Internally, Visual MPC makes", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 205, + 376, + 217 + ], + "spans": [ + { + "bbox": [ + 106, + 205, + 376, + 217 + ], + "score": 1.0, + "content": "action-conditioned fixed-time forward predictions of future object", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 216, + 376, + 228 + ], + "spans": [ + { + "bbox": [ + 106, + 216, + 376, + 228 + ], + "score": 1.0, + "content": "positions to find an action sequence that reaches the subgoal object", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6.5, + "bbox_fs": [ + 105, + 139, + 376, + 228 + ] + }, + { + "type": "table", + "bbox": [ + 385, + 141, + 504, + 189 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 385, + 141, + 504, + 189 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 385, + 141, + 504, + 189 + ], + "spans": [ + { + "bbox": [ + 385, + 141, + 504, + 189 + ], + "score": 0.971, + "html": "
2-object3-object
direct12.9±0.615.8±0.6
FIX12.5±0.517.6±0.6
GENMIN11.9±0.612.9±0.7
", + "type": "table", + "image_path": "91aa2871f959f5c4caab3f23c69cc737c597c3a5f2593fa436f4e4dcd82aec90.jpg" + } + ] + } + ], + "index": 11.5, + "virtual_lines": [ + { + "bbox": [ + 385, + 141, + 504, + 165.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 385, + 165.0, + 504, + 189.0 + ], + "spans": [], + "index": 12 + } + ] + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 384, + 197, + 505, + 217 + ], + "lines": [ + { + "bbox": [ + 382, + 196, + 506, + 208 + ], + "spans": [ + { + "bbox": [ + 382, + 196, + 506, + 208 + ], + "score": 1.0, + "content": "Table 2: Multi-object pushing er-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 383, + 207, + 430, + 218 + ], + "spans": [ + { + "bbox": [ + 383, + 207, + 430, + 218 + ], + "score": 1.0, + "content": "rors (in cm).", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5, + "bbox_fs": [ + 382, + 196, + 506, + 218 + ] + }, + { + "type": "text", + "bbox": [ + 110, + 227, + 487, + 238 + ], + "lines": [ + { + "bbox": [ + 108, + 225, + 489, + 240 + ], + "spans": [ + { + "bbox": [ + 108, + 225, + 489, + 240 + ], + "score": 1.0, + "content": "positions, with a planning horizon of 15. Additional implementation details are in Appendix G.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15, + "bbox_fs": [ + 108, + 225, + 489, + 240 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 244, + 505, + 354 + ], + "lines": [ + { + "bbox": [ + 106, + 243, + 505, + 256 + ], + "spans": [ + { + "bbox": [ + 106, + 243, + 505, + 256 + ], + "score": 1.0, + "content": "Given start and goal images, our model produces a subgoal. Visual MPC plans towards this subgoal", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 254, + 506, + 268 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 506, + 268 + ], + "score": 1.0, + "content": "for half the episode length, then switches to the final goal. We compare this scheme against (i)", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 265, + 505, + 278 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 505, + 278 + ], + "score": 1.0, + "content": "“direct”: planning directly towards the final goal for the entire episode length, and (ii) FIX: subgoals", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 276, + 506, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 506, + 289 + ], + "score": 1.0, + "content": "from a center-frame predictor. The error measure is the mean of object distances to goal states (lower", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 288, + 506, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 407, + 300 + ], + "score": 1.0, + "content": "is better). As an upper bound, single-object pushing with the planner yields", + "type": "text" + }, + { + "bbox": [ + 408, + 288, + 434, + 298 + ], + "score": 0.85, + "content": "{ \\sim } 5 \\mathrm { c m }", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 288, + 506, + 300 + ], + "score": 1.0, + "content": "error. Results for", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 299, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 106, + 299, + 505, + 312 + ], + "score": 1.0, + "content": "two-object and three-object pushing are shown in Table 2. GENMIN does best on both, but especially", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 309, + 506, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 506, + 322 + ], + "score": 1.0, + "content": "on the more complex three-object task. Since Visual MPC has thus far been demonstrated to work", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 321, + 506, + 333 + ], + "spans": [ + { + "bbox": [ + 106, + 321, + 506, + 333 + ], + "score": 1.0, + "content": "only on pushing tasks, our hierarchical planning evaluation is also limited to this task. Going forward,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 331, + 505, + 344 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 505, + 344 + ], + "score": 1.0, + "content": "we plan to adapt Visual MPC to allow testing TAP on more complex temporally extended tasks like", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 342, + 444, + 355 + ], + "spans": [ + { + "bbox": [ + 106, + 342, + 444, + 355 + ], + "score": 1.0, + "content": "block-stacking, where direct planning breaks down and subgoals offer greater value.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 20.5, + "bbox_fs": [ + 105, + 243, + 506, + 355 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 381, + 201, + 393 + ], + "lines": [ + { + "bbox": [ + 104, + 378, + 203, + 397 + ], + "spans": [ + { + "bbox": [ + 104, + 378, + 203, + 397 + ], + "score": 1.0, + "content": "5 CONCLUSIONS", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 412, + 505, + 522 + ], + "lines": [ + { + "bbox": [ + 105, + 412, + 506, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 506, + 425 + ], + "score": 1.0, + "content": "The standard paradigm for prediction tasks demands that a predictor not only make good predictions,", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 424, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 106, + 424, + 505, + 437 + ], + "score": 1.0, + "content": "but that it make them on a set schedule. We have argued for redefining the prediction task so that the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 435, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 106, + 435, + 505, + 447 + ], + "score": 1.0, + "content": "predictor need only care that its prediction occur at some time, rather than that it occur at a specific", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 446, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 446, + 505, + 459 + ], + "score": 1.0, + "content": "scheduled time. We define this time-agnostic prediction task and propose novel technical approaches", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 457, + 506, + 469 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 506, + 469 + ], + "score": 1.0, + "content": "to solve it, that require relatively small changes to standard prediction methods. Our results show that", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 468, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 106, + 468, + 505, + 480 + ], + "score": 1.0, + "content": "reframing prediction objectives in this way yields higher quality predictions that are also semantically", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 479, + 504, + 491 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 504, + 491 + ], + "score": 1.0, + "content": "coherent—unattached to a rigid schedule of regularly specified timestamps, model predictions instead", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 489, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 505, + 502 + ], + "score": 1.0, + "content": "naturally attach to specific semantic “bottleneck” events, like a grasp. In our preliminary experiments", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 501, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 106, + 501, + 505, + 513 + ], + "score": 1.0, + "content": "with a hierarchical visual planner, our results suggest that such predictions could serve as useful", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 511, + 219, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 219, + 524 + ], + "score": 1.0, + "content": "subgoals for complex tasks.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 31.5, + "bbox_fs": [ + 105, + 412, + 506, + 524 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 528, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 106, + 529, + 504, + 540 + ], + "spans": [ + { + "bbox": [ + 106, + 529, + 504, + 540 + ], + "score": 1.0, + "content": "In future work, we would like to address some limitations of our TAP formulation, of which we will", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 539, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 505, + 551 + ], + "score": 1.0, + "content": "mention two here. First, TAP currently benefits not only from selecting which times to predict, but", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 550, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 505, + 563 + ], + "score": 1.0, + "content": "also from not having to provide timestamps attached to its predictions. We would like to study: could", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 561, + 505, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 505, + 575 + ], + "score": 1.0, + "content": "we retain the benefits of time-agnostic prediction while also providing timestamps for when each", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 572, + 504, + 584 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 504, + 584 + ], + "score": 1.0, + "content": "predicted state will occur? Second, our current TAP formulation may not generalize to prediction", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 583, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 506, + 596 + ], + "score": 1.0, + "content": "problems in all settings of interest. As an example, for videos of juggling or waving, which involve", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 594, + 506, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 506, + 606 + ], + "score": 1.0, + "content": "repeated frames, TAP might collapse to predicting the input state repeatedly. We would like to", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 604, + 505, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 411, + 619 + ], + "score": 1.0, + "content": "investigate more general TAP formulations: for example, rather than choosing", + "type": "text" + }, + { + "bbox": [ + 412, + 605, + 422, + 617 + ], + "score": 0.89, + "content": "\\mathcal { E } _ { t } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 422, + 604, + 505, + 619 + ], + "score": 1.0, + "content": "in Eq 5 to encourage", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 616, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 505, + 629 + ], + "score": 1.0, + "content": "predicting farther away times, we could conceivably penalize predictions that look too similar to the", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 627, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 505, + 640 + ], + "score": 1.0, + "content": "input context frames. More broadly, we believe that our results thus far hold great promise for many", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 637, + 507, + 652 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 507, + 652 + ], + "score": 1.0, + "content": "applications of prediction including hierarchical planning and model-based reinforcement learning,", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 649, + 289, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 289, + 661 + ], + "score": 1.0, + "content": "and we hope to build further on these results.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 42.5, + "bbox_fs": [ + 105, + 529, + 507, + 661 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 666, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 505, + 677 + ], + "score": 1.0, + "content": "Acknowledgements. We thank Alex Lee and Chelsea Finn for helpful discussions and Sudeep Dasari", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "for help with the simulation framework and for generating the simulated data used in this work. We", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "thank Kate Rakelly, Kyle Hsu, and Allan Jabri for feedback on early drafts. This work was supported", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "by Berkeley DeepDrive, NSF IIS-1614653, NSF IIS-1633310, and an Office of Naval Research", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 708, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 506, + 723 + ], + "score": 1.0, + "content": "Young Investigator Program award. The NVIDIA DGX-1 used for this research was donated by the", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 720, + 198, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 198, + 734 + ], + "score": 1.0, + "content": "NVIDIA Corporation.", + "type": "text" + } + ], + "index": 54 + } + ], + "index": 51.5, + "bbox_fs": [ + 105, + 666, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 81, + 176, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 176, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 176, + 94 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 100, + 504, + 123 + ], + "lines": [ + { + "bbox": [ + 105, + 99, + 506, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 506, + 113 + ], + "score": 1.0, + "content": "Mohammad Babaeizadeh, Chelsea Finn, Dumitru Erhan, Roy H Campbell, and Sergey Levine.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 117, + 111, + 327, + 123 + ], + "spans": [ + { + "bbox": [ + 117, + 111, + 327, + 123 + ], + "score": 1.0, + "content": "Stochastic variational video prediction. ICLR, 2018.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1.5 + }, + { + "type": "text", + "bbox": [ + 106, + 128, + 504, + 152 + ], + "lines": [ + { + "bbox": [ + 105, + 128, + 505, + 142 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 505, + 142 + ], + "score": 1.0, + "content": "Pierre-Luc Bacon. On the bottleneck concept for options discovery. M.S. Thesis, McGill University,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 139, + 143, + 153 + ], + "spans": [ + { + "bbox": [ + 115, + 139, + 143, + 153 + ], + "score": 1.0, + "content": "2013.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 158, + 504, + 181 + ], + "lines": [ + { + "bbox": [ + 105, + 158, + 505, + 171 + ], + "spans": [ + { + "bbox": [ + 105, + 158, + 505, + 171 + ], + "score": 1.0, + "content": "Moshe Bar. The proactive brain: memory for predictions. Philosophical Transactions of the Royal", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 169, + 361, + 182 + ], + "spans": [ + { + "bbox": [ + 115, + 169, + 361, + 182 + ], + "score": 1.0, + "content": "Society B: Biological Sciences, 364(1521):1235–1243, 2009.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 107, + 187, + 504, + 211 + ], + "lines": [ + { + "bbox": [ + 106, + 186, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 106, + 186, + 505, + 201 + ], + "score": 1.0, + "content": "Andy Clark. Whatever next? predictive brains, situated agents, and the future of cognitive science.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 116, + 199, + 331, + 210 + ], + "spans": [ + { + "bbox": [ + 116, + 199, + 331, + 210 + ], + "score": 1.0, + "content": "Behavioral and brain sciences, 36(3):181–204, 2013.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 106, + 217, + 505, + 240 + ], + "lines": [ + { + "bbox": [ + 105, + 216, + 505, + 231 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 505, + 231 + ], + "score": 1.0, + "content": "Emily Denton and Rob Fergus. Stochastic video generation with a learned prior. arXiv preprint", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 228, + 219, + 240 + ], + "spans": [ + { + "bbox": [ + 115, + 228, + 219, + 240 + ], + "score": 1.0, + "content": "arXiv:1802.07687, 2018.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 106, + 246, + 505, + 270 + ], + "lines": [ + { + "bbox": [ + 106, + 246, + 505, + 259 + ], + "spans": [ + { + "bbox": [ + 106, + 246, + 505, + 259 + ], + "score": 1.0, + "content": "Frederik Ebert, Chelsea Finn, Alex X. Lee, and Sergey Levine. Self-supervised visual planning with", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 258, + 283, + 269 + ], + "spans": [ + { + "bbox": [ + 116, + 258, + 283, + 269 + ], + "score": 1.0, + "content": "temporal skip connections. CORL, 2017.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 108, + 275, + 504, + 299 + ], + "lines": [ + { + "bbox": [ + 106, + 275, + 506, + 290 + ], + "spans": [ + { + "bbox": [ + 106, + 275, + 506, + 290 + ], + "score": 1.0, + "content": "Chelsea Finn and Sergey Levine. Deep visual foresight for planning robot motion. In International", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 117, + 288, + 339, + 299 + ], + "spans": [ + { + "bbox": [ + 117, + 288, + 339, + 299 + ], + "score": 1.0, + "content": "Conference on Robotics and Automation (ICRA), 2017.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 106, + 304, + 505, + 329 + ], + "lines": [ + { + "bbox": [ + 106, + 305, + 505, + 318 + ], + "spans": [ + { + "bbox": [ + 106, + 305, + 505, + 318 + ], + "score": 1.0, + "content": "Chelsea Finn, Ian Goodfellow, and Sergey Levine. Unsupervised learning for physical interaction", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 316, + 450, + 329 + ], + "spans": [ + { + "bbox": [ + 116, + 316, + 450, + 329 + ], + "score": 1.0, + "content": "through video prediction. In Neural Information Processing Systems (NIPS), 2016.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 107, + 334, + 504, + 369 + ], + "lines": [ + { + "bbox": [ + 105, + 334, + 506, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 506, + 348 + ], + "score": 1.0, + "content": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 346, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 115, + 346, + 506, + 358 + ], + "score": 1.0, + "content": "Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural informa-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 116, + 357, + 305, + 369 + ], + "spans": [ + { + "bbox": [ + 116, + 357, + 305, + 369 + ], + "score": 1.0, + "content": "tion processing systems, pp. 2672–2680, 2014.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 108, + 375, + 504, + 409 + ], + "lines": [ + { + "bbox": [ + 105, + 375, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 505, + 388 + ], + "score": 1.0, + "content": "Raia Hadsell, Sumit Chopra, and Yann LeCun. Dimensionality reduction by learning an invariant", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 386, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 115, + 386, + 506, + 399 + ], + "score": 1.0, + "content": "mapping. In Computer vision and pattern recognition, 2006 IEEE computer society conference on,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 116, + 398, + 275, + 410 + ], + "spans": [ + { + "bbox": [ + 116, + 398, + 275, + 410 + ], + "score": 1.0, + "content": "volume 2, pp. 1735–1742. IEEE, 2006.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 106, + 415, + 378, + 428 + ], + "lines": [ + { + "bbox": [ + 104, + 415, + 379, + 430 + ], + "spans": [ + { + "bbox": [ + 104, + 415, + 379, + 430 + ], + "score": 1.0, + "content": "Jakob Hohwy. The predictive mind. Oxford University Press, 2013.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 433, + 505, + 457 + ], + "lines": [ + { + "bbox": [ + 105, + 433, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 505, + 447 + ], + "score": 1.0, + "content": "Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 116, + 445, + 307, + 456 + ], + "spans": [ + { + "bbox": [ + 116, + 445, + 307, + 456 + ], + "score": 1.0, + "content": "conditional adversarial networks. CVPR, 2017.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 107, + 463, + 503, + 487 + ], + "lines": [ + { + "bbox": [ + 106, + 464, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 106, + 464, + 505, + 477 + ], + "score": 1.0, + "content": "Dinesh Jayaraman and Kristen Grauman. Learning image representations tied to ego-motion. In", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 474, + 494, + 487 + ], + "spans": [ + { + "bbox": [ + 115, + 474, + 494, + 487 + ], + "score": 1.0, + "content": "Proceedings of the IEEE International Conference on Computer Vision, pp. 1413–1421, 2015.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 106, + 492, + 504, + 516 + ], + "lines": [ + { + "bbox": [ + 105, + 492, + 506, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 506, + 506 + ], + "score": 1.0, + "content": "Nal Kalchbrenner, Aaron van den Oord, Karen Simonyan, Ivo Danihelka, Oriol Vinyals, Alex Graves,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 117, + 504, + 473, + 517 + ], + "spans": [ + { + "bbox": [ + 117, + 504, + 473, + 517 + ], + "score": 1.0, + "content": "and Koray Kavukcuoglu. Video pixel networks. arXiv preprint arXiv:1610.00527, 2016.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 107, + 522, + 504, + 545 + ], + "lines": [ + { + "bbox": [ + 105, + 521, + 506, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 521, + 506, + 536 + ], + "score": 1.0, + "content": "Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 533, + 214, + 544 + ], + "spans": [ + { + "bbox": [ + 115, + 533, + 214, + 544 + ], + "score": 1.0, + "content": "arXiv:1312.6114, 2013.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5 + }, + { + "type": "text", + "bbox": [ + 106, + 551, + 504, + 575 + ], + "lines": [ + { + "bbox": [ + 105, + 550, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 505, + 565 + ], + "score": 1.0, + "content": "Kris M Kitani, Brian D Ziebart, James Andrew Bagnell, and Martial Hebert. Activity forecasting. In", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 562, + 409, + 576 + ], + "spans": [ + { + "bbox": [ + 116, + 562, + 409, + 576 + ], + "score": 1.0, + "content": "European Conference on Computer Vision, pp. 201–214. Springer, 2012.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 107, + 580, + 506, + 615 + ], + "lines": [ + { + "bbox": [ + 105, + 579, + 506, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 506, + 594 + ], + "score": 1.0, + "content": "Dirk P Kroese, Reuven Y Rubinstein, Izack Cohen, Sergey Porotsky, and Thomas Taimre. Cross-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 592, + 507, + 604 + ], + "spans": [ + { + "bbox": [ + 115, + 592, + 507, + 604 + ], + "score": 1.0, + "content": "entropy method. In Encyclopedia of Operations Research and Management Science, pp. 326–333.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 115, + 602, + 181, + 617 + ], + "spans": [ + { + "bbox": [ + 115, + 602, + 181, + 617 + ], + "score": 1.0, + "content": "Springer, 2013.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 106, + 621, + 505, + 645 + ], + "lines": [ + { + "bbox": [ + 106, + 621, + 506, + 634 + ], + "spans": [ + { + "bbox": [ + 106, + 621, + 506, + 634 + ], + "score": 1.0, + "content": "Anders Boesen Lindbo Larsen, Søren Kaae Sønderby, Hugo Larochelle, and Ole Winther. Autoen-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 116, + 632, + 393, + 645 + ], + "spans": [ + { + "bbox": [ + 116, + 632, + 393, + 645 + ], + "score": 1.0, + "content": "coding beyond pixels using a learned similarity metric. ICML, 2016.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37.5 + }, + { + "type": "text", + "bbox": [ + 106, + 650, + 503, + 674 + ], + "lines": [ + { + "bbox": [ + 106, + 649, + 504, + 664 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 504, + 664 + ], + "score": 1.0, + "content": "Alex X Lee, Richard Zhang, Frederik Ebert, Pieter Abbeel, Chelsea Finn, and Sergey Levine.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 117, + 662, + 439, + 673 + ], + "spans": [ + { + "bbox": [ + 117, + 662, + 439, + 673 + ], + "score": 1.0, + "content": "Stochastic adversarial video prediction. arXiv preprint arXiv:1804.01523, 2018.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39.5 + }, + { + "type": "text", + "bbox": [ + 107, + 679, + 503, + 703 + ], + "lines": [ + { + "bbox": [ + 105, + 679, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 679, + 505, + 693 + ], + "score": 1.0, + "content": "Michael Mathieu, Camille Couprie, and Yann LeCun. Deep multi-scale video prediction beyond", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 116, + 692, + 356, + 702 + ], + "spans": [ + { + "bbox": [ + 116, + 692, + 356, + 702 + ], + "score": 1.0, + "content": "mean square error. arXiv preprint arXiv:1511.05440, 2015.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "Amy McGovern and Andrew G Barto. Automatic discovery of subgoals in reinforcement learning", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 721, + 271, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 271, + 732 + ], + "score": 1.0, + "content": "using diverse density. In ICML, 2001.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43.5 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 298, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 298, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "10", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 81, + 176, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 176, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 176, + 94 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 100, + 504, + 123 + ], + "lines": [ + { + "bbox": [ + 105, + 99, + 506, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 506, + 113 + ], + "score": 1.0, + "content": "Mohammad Babaeizadeh, Chelsea Finn, Dumitru Erhan, Roy H Campbell, and Sergey Levine.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 117, + 111, + 327, + 123 + ], + "spans": [ + { + "bbox": [ + 117, + 111, + 327, + 123 + ], + "score": 1.0, + "content": "Stochastic variational video prediction. ICLR, 2018.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1.5, + "bbox_fs": [ + 105, + 99, + 506, + 123 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 128, + 504, + 152 + ], + "lines": [ + { + "bbox": [ + 105, + 128, + 505, + 142 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 505, + 142 + ], + "score": 1.0, + "content": "Pierre-Luc Bacon. On the bottleneck concept for options discovery. M.S. Thesis, McGill University,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 139, + 143, + 153 + ], + "spans": [ + { + "bbox": [ + 115, + 139, + 143, + 153 + ], + "score": 1.0, + "content": "2013.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 128, + 505, + 153 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 158, + 504, + 181 + ], + "lines": [ + { + "bbox": [ + 105, + 158, + 505, + 171 + ], + "spans": [ + { + "bbox": [ + 105, + 158, + 505, + 171 + ], + "score": 1.0, + "content": "Moshe Bar. The proactive brain: memory for predictions. Philosophical Transactions of the Royal", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 169, + 361, + 182 + ], + "spans": [ + { + "bbox": [ + 115, + 169, + 361, + 182 + ], + "score": 1.0, + "content": "Society B: Biological Sciences, 364(1521):1235–1243, 2009.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5, + "bbox_fs": [ + 105, + 158, + 505, + 182 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 187, + 504, + 211 + ], + "lines": [ + { + "bbox": [ + 106, + 186, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 106, + 186, + 505, + 201 + ], + "score": 1.0, + "content": "Andy Clark. Whatever next? predictive brains, situated agents, and the future of cognitive science.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 116, + 199, + 331, + 210 + ], + "spans": [ + { + "bbox": [ + 116, + 199, + 331, + 210 + ], + "score": 1.0, + "content": "Behavioral and brain sciences, 36(3):181–204, 2013.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5, + "bbox_fs": [ + 106, + 186, + 505, + 210 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 217, + 505, + 240 + ], + "lines": [ + { + "bbox": [ + 105, + 216, + 505, + 231 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 505, + 231 + ], + "score": 1.0, + "content": "Emily Denton and Rob Fergus. Stochastic video generation with a learned prior. arXiv preprint", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 228, + 219, + 240 + ], + "spans": [ + { + "bbox": [ + 115, + 228, + 219, + 240 + ], + "score": 1.0, + "content": "arXiv:1802.07687, 2018.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 216, + 505, + 240 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 246, + 505, + 270 + ], + "lines": [ + { + "bbox": [ + 106, + 246, + 505, + 259 + ], + "spans": [ + { + "bbox": [ + 106, + 246, + 505, + 259 + ], + "score": 1.0, + "content": "Frederik Ebert, Chelsea Finn, Alex X. Lee, and Sergey Levine. Self-supervised visual planning with", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 258, + 283, + 269 + ], + "spans": [ + { + "bbox": [ + 116, + 258, + 283, + 269 + ], + "score": 1.0, + "content": "temporal skip connections. CORL, 2017.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5, + "bbox_fs": [ + 106, + 246, + 505, + 269 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 275, + 504, + 299 + ], + "lines": [ + { + "bbox": [ + 106, + 275, + 506, + 290 + ], + "spans": [ + { + "bbox": [ + 106, + 275, + 506, + 290 + ], + "score": 1.0, + "content": "Chelsea Finn and Sergey Levine. Deep visual foresight for planning robot motion. In International", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 117, + 288, + 339, + 299 + ], + "spans": [ + { + "bbox": [ + 117, + 288, + 339, + 299 + ], + "score": 1.0, + "content": "Conference on Robotics and Automation (ICRA), 2017.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5, + "bbox_fs": [ + 106, + 275, + 506, + 299 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 304, + 505, + 329 + ], + "lines": [ + { + "bbox": [ + 106, + 305, + 505, + 318 + ], + "spans": [ + { + "bbox": [ + 106, + 305, + 505, + 318 + ], + "score": 1.0, + "content": "Chelsea Finn, Ian Goodfellow, and Sergey Levine. Unsupervised learning for physical interaction", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 316, + 450, + 329 + ], + "spans": [ + { + "bbox": [ + 116, + 316, + 450, + 329 + ], + "score": 1.0, + "content": "through video prediction. In Neural Information Processing Systems (NIPS), 2016.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5, + "bbox_fs": [ + 106, + 305, + 505, + 329 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 334, + 504, + 369 + ], + "lines": [ + { + "bbox": [ + 105, + 334, + 506, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 506, + 348 + ], + "score": 1.0, + "content": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 346, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 115, + 346, + 506, + 358 + ], + "score": 1.0, + "content": "Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural informa-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 116, + 357, + 305, + 369 + ], + "spans": [ + { + "bbox": [ + 116, + 357, + 305, + 369 + ], + "score": 1.0, + "content": "tion processing systems, pp. 2672–2680, 2014.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 334, + 506, + 369 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 375, + 504, + 409 + ], + "lines": [ + { + "bbox": [ + 105, + 375, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 505, + 388 + ], + "score": 1.0, + "content": "Raia Hadsell, Sumit Chopra, and Yann LeCun. Dimensionality reduction by learning an invariant", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 386, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 115, + 386, + 506, + 399 + ], + "score": 1.0, + "content": "mapping. In Computer vision and pattern recognition, 2006 IEEE computer society conference on,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 116, + 398, + 275, + 410 + ], + "spans": [ + { + "bbox": [ + 116, + 398, + 275, + 410 + ], + "score": 1.0, + "content": "volume 2, pp. 1735–1742. IEEE, 2006.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 375, + 506, + 410 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 415, + 378, + 428 + ], + "lines": [ + { + "bbox": [ + 104, + 415, + 379, + 430 + ], + "spans": [ + { + "bbox": [ + 104, + 415, + 379, + 430 + ], + "score": 1.0, + "content": "Jakob Hohwy. The predictive mind. Oxford University Press, 2013.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23, + "bbox_fs": [ + 104, + 415, + 379, + 430 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 433, + 505, + 457 + ], + "lines": [ + { + "bbox": [ + 105, + 433, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 505, + 447 + ], + "score": 1.0, + "content": "Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 116, + 445, + 307, + 456 + ], + "spans": [ + { + "bbox": [ + 116, + 445, + 307, + 456 + ], + "score": 1.0, + "content": "conditional adversarial networks. CVPR, 2017.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5, + "bbox_fs": [ + 105, + 433, + 505, + 456 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 463, + 503, + 487 + ], + "lines": [ + { + "bbox": [ + 106, + 464, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 106, + 464, + 505, + 477 + ], + "score": 1.0, + "content": "Dinesh Jayaraman and Kristen Grauman. Learning image representations tied to ego-motion. In", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 474, + 494, + 487 + ], + "spans": [ + { + "bbox": [ + 115, + 474, + 494, + 487 + ], + "score": 1.0, + "content": "Proceedings of the IEEE International Conference on Computer Vision, pp. 1413–1421, 2015.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5, + "bbox_fs": [ + 106, + 464, + 505, + 487 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 492, + 504, + 516 + ], + "lines": [ + { + "bbox": [ + 105, + 492, + 506, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 506, + 506 + ], + "score": 1.0, + "content": "Nal Kalchbrenner, Aaron van den Oord, Karen Simonyan, Ivo Danihelka, Oriol Vinyals, Alex Graves,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 117, + 504, + 473, + 517 + ], + "spans": [ + { + "bbox": [ + 117, + 504, + 473, + 517 + ], + "score": 1.0, + "content": "and Koray Kavukcuoglu. Video pixel networks. arXiv preprint arXiv:1610.00527, 2016.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28.5, + "bbox_fs": [ + 105, + 492, + 506, + 517 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 522, + 504, + 545 + ], + "lines": [ + { + "bbox": [ + 105, + 521, + 506, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 521, + 506, + 536 + ], + "score": 1.0, + "content": "Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 533, + 214, + 544 + ], + "spans": [ + { + "bbox": [ + 115, + 533, + 214, + 544 + ], + "score": 1.0, + "content": "arXiv:1312.6114, 2013.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 521, + 506, + 544 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 551, + 504, + 575 + ], + "lines": [ + { + "bbox": [ + 105, + 550, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 505, + 565 + ], + "score": 1.0, + "content": "Kris M Kitani, Brian D Ziebart, James Andrew Bagnell, and Martial Hebert. Activity forecasting. In", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 562, + 409, + 576 + ], + "spans": [ + { + "bbox": [ + 116, + 562, + 409, + 576 + ], + "score": 1.0, + "content": "European Conference on Computer Vision, pp. 201–214. Springer, 2012.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 550, + 505, + 576 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 580, + 506, + 615 + ], + "lines": [ + { + "bbox": [ + 105, + 579, + 506, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 506, + 594 + ], + "score": 1.0, + "content": "Dirk P Kroese, Reuven Y Rubinstein, Izack Cohen, Sergey Porotsky, and Thomas Taimre. Cross-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 592, + 507, + 604 + ], + "spans": [ + { + "bbox": [ + 115, + 592, + 507, + 604 + ], + "score": 1.0, + "content": "entropy method. In Encyclopedia of Operations Research and Management Science, pp. 326–333.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 115, + 602, + 181, + 617 + ], + "spans": [ + { + "bbox": [ + 115, + 602, + 181, + 617 + ], + "score": 1.0, + "content": "Springer, 2013.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 579, + 507, + 617 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 621, + 505, + 645 + ], + "lines": [ + { + "bbox": [ + 106, + 621, + 506, + 634 + ], + "spans": [ + { + "bbox": [ + 106, + 621, + 506, + 634 + ], + "score": 1.0, + "content": "Anders Boesen Lindbo Larsen, Søren Kaae Sønderby, Hugo Larochelle, and Ole Winther. Autoen-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 116, + 632, + 393, + 645 + ], + "spans": [ + { + "bbox": [ + 116, + 632, + 393, + 645 + ], + "score": 1.0, + "content": "coding beyond pixels using a learned similarity metric. ICML, 2016.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37.5, + "bbox_fs": [ + 106, + 621, + 506, + 645 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 650, + 503, + 674 + ], + "lines": [ + { + "bbox": [ + 106, + 649, + 504, + 664 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 504, + 664 + ], + "score": 1.0, + "content": "Alex X Lee, Richard Zhang, Frederik Ebert, Pieter Abbeel, Chelsea Finn, and Sergey Levine.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 117, + 662, + 439, + 673 + ], + "spans": [ + { + "bbox": [ + 117, + 662, + 439, + 673 + ], + "score": 1.0, + "content": "Stochastic adversarial video prediction. arXiv preprint arXiv:1804.01523, 2018.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39.5, + "bbox_fs": [ + 106, + 649, + 504, + 673 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 679, + 503, + 703 + ], + "lines": [ + { + "bbox": [ + 105, + 679, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 679, + 505, + 693 + ], + "score": 1.0, + "content": "Michael Mathieu, Camille Couprie, and Yann LeCun. Deep multi-scale video prediction beyond", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 116, + 692, + 356, + 702 + ], + "spans": [ + { + "bbox": [ + 116, + 692, + 356, + 702 + ], + "score": 1.0, + "content": "mean square error. arXiv preprint arXiv:1511.05440, 2015.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5, + "bbox_fs": [ + 105, + 679, + 505, + 702 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "Amy McGovern and Andrew G Barto. Automatic discovery of subgoals in reinforcement learning", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 721, + 271, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 271, + 732 + ], + "score": 1.0, + "content": "using diverse density. In ICML, 2001.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43.5, + "bbox_fs": [ + 106, + 708, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 505, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "Jan Hendrik Metzen. Online skill discovery using graph-based clustering. In European Workshop on", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 93, + 288, + 106 + ], + "spans": [ + { + "bbox": [ + 115, + 93, + 288, + 106 + ], + "score": 1.0, + "content": "Reinforcement Learning, pp. 77–88, 2013.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 105, + 111, + 504, + 135 + ], + "lines": [ + { + "bbox": [ + 105, + 110, + 505, + 125 + ], + "spans": [ + { + "bbox": [ + 105, + 110, + 505, + 125 + ], + "score": 1.0, + "content": "Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 123, + 214, + 134 + ], + "spans": [ + { + "bbox": [ + 115, + 123, + 214, + 134 + ], + "score": 1.0, + "content": "arXiv:1411.1784, 2014.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 106, + 140, + 504, + 174 + ], + "lines": [ + { + "bbox": [ + 105, + 140, + 506, + 154 + ], + "spans": [ + { + "bbox": [ + 105, + 140, + 506, + 154 + ], + "score": 1.0, + "content": "Hossein Mobahi, Ronan Collobert, and Jason Weston. Deep learning from temporal coherence in", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 150, + 506, + 166 + ], + "spans": [ + { + "bbox": [ + 115, + 150, + 506, + 166 + ], + "score": 1.0, + "content": "video. In Proceedings of the 26th Annual International Conference on Machine Learning, pp.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 162, + 209, + 174 + ], + "spans": [ + { + "bbox": [ + 115, + 162, + 209, + 174 + ], + "score": 1.0, + "content": "737–744. ACM, 2009.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 104, + 180, + 504, + 204 + ], + "lines": [ + { + "bbox": [ + 106, + 180, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 106, + 180, + 505, + 194 + ], + "score": 1.0, + "content": "Alexander Neitz, Giambattista Parascandolo, Stefan Bauer, and Bernhard Schlkopf. Adaptive skip", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 192, + 425, + 204 + ], + "spans": [ + { + "bbox": [ + 115, + 192, + 425, + 204 + ], + "score": 1.0, + "content": "intervals: Temporal abstraction for recurrent dynamical models. NIPS, 2018.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 106, + 210, + 505, + 244 + ], + "lines": [ + { + "bbox": [ + 106, + 210, + 506, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 210, + 506, + 222 + ], + "score": 1.0, + "content": "Augustus Odena, Vincent Dumoulin, and Chris Olah. Deconvolution and checkerboard arti-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 221, + 506, + 234 + ], + "spans": [ + { + "bbox": [ + 115, + 221, + 506, + 234 + ], + "score": 1.0, + "content": "facts. Distill, 2016. doi: 10.23915/distill.00003. URL http://distill.pub/2016/", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 117, + 234, + 235, + 243 + ], + "spans": [ + { + "bbox": [ + 117, + 234, + 235, + 243 + ], + "score": 1.0, + "content": "deconv-checkerboard.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 105, + 250, + 504, + 284 + ], + "lines": [ + { + "bbox": [ + 106, + 250, + 505, + 262 + ], + "spans": [ + { + "bbox": [ + 106, + 250, + 505, + 262 + ], + "score": 1.0, + "content": "Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-conditional", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 260, + 505, + 275 + ], + "spans": [ + { + "bbox": [ + 115, + 260, + 505, + 275 + ], + "score": 1.0, + "content": "video prediction using deep networks in atari games. In Advances in Neural Information Processing", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 115, + 272, + 178, + 285 + ], + "spans": [ + { + "bbox": [ + 115, + 272, + 178, + 285 + ], + "score": 1.0, + "content": "Systems, 2015.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 105, + 290, + 505, + 313 + ], + "lines": [ + { + "bbox": [ + 106, + 291, + 505, + 303 + ], + "spans": [ + { + "bbox": [ + 106, + 291, + 505, + 303 + ], + "score": 1.0, + "content": "Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 301, + 279, + 314 + ], + "spans": [ + { + "bbox": [ + 115, + 301, + 279, + 314 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1601.06759, 2016.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 104, + 319, + 504, + 343 + ], + "lines": [ + { + "bbox": [ + 106, + 318, + 505, + 334 + ], + "spans": [ + { + "bbox": [ + 106, + 318, + 505, + 334 + ], + "score": 1.0, + "content": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 331, + 468, + 343 + ], + "spans": [ + { + "bbox": [ + 115, + 331, + 468, + 343 + ], + "score": 1.0, + "content": "convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 108, + 348, + 505, + 383 + ], + "lines": [ + { + "bbox": [ + 107, + 349, + 505, + 360 + ], + "spans": [ + { + "bbox": [ + 107, + 349, + 505, + 360 + ], + "score": 1.0, + "content": "MarcAurelio Ranzato, Arthur Szlam, Joan Bruna, Michael Mathieu, Ronan Collobert, and Sumit", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 360, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 116, + 360, + 505, + 373 + ], + "score": 1.0, + "content": "Chopra. Video (language) modeling: a baseline for generative models of natural videos. arXiv", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 372, + 249, + 383 + ], + "spans": [ + { + "bbox": [ + 115, + 372, + 249, + 383 + ], + "score": 1.0, + "content": "preprint arXiv:1412.6604, 2014.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 105, + 389, + 505, + 412 + ], + "lines": [ + { + "bbox": [ + 106, + 388, + 506, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 388, + 506, + 403 + ], + "score": 1.0, + "content": "Ozg ¨ ur¨ S¸ims¸ek and Andrew G Barto. Skill characterization based on betweenness. In Advances in", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 115, + 400, + 365, + 413 + ], + "spans": [ + { + "bbox": [ + 115, + 400, + 365, + 413 + ], + "score": 1.0, + "content": "neural information processing systems, pp. 1497–1504, 2009.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 105, + 418, + 505, + 442 + ], + "lines": [ + { + "bbox": [ + 106, + 419, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 106, + 419, + 505, + 431 + ], + "score": 1.0, + "content": "Richard S Sutton, Doina Precup, and Satinder Singh. Between mdps and semi-mdps: A framework", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 116, + 429, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 116, + 429, + 506, + 442 + ], + "score": 1.0, + "content": "for temporal abstraction in reinforcement learning. Artificial intelligence, 112(1-2):181–211, 1999.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 107, + 447, + 505, + 481 + ], + "lines": [ + { + "bbox": [ + 106, + 447, + 506, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 447, + 506, + 461 + ], + "score": 1.0, + "content": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based con-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 457, + 507, + 474 + ], + "spans": [ + { + "bbox": [ + 115, + 457, + 507, + 474 + ], + "score": 1.0, + "content": "trol. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 470, + 218, + 481 + ], + "spans": [ + { + "bbox": [ + 116, + 470, + 218, + 481 + ], + "score": 1.0, + "content": "5026–5033. IEEE, 2012.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 106, + 487, + 504, + 522 + ], + "lines": [ + { + "bbox": [ + 106, + 488, + 506, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 488, + 506, + 500 + ], + "score": 1.0, + "content": "Aaron van den Oord, Nal Kalchbrenner, Lasse Espeholt, Oriol Vinyals, Alex Graves, et al. Conditional", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 499, + 507, + 512 + ], + "spans": [ + { + "bbox": [ + 115, + 499, + 507, + 512 + ], + "score": 1.0, + "content": "image generation with pixelcnn decoders. In Advances in Neural Information Processing Systems,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 511, + 207, + 522 + ], + "spans": [ + { + "bbox": [ + 115, + 511, + 207, + 522 + ], + "score": 1.0, + "content": "pp. 4790–4798, 2016.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 105, + 528, + 505, + 551 + ], + "lines": [ + { + "bbox": [ + 105, + 527, + 505, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 505, + 541 + ], + "score": 1.0, + "content": "Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. In", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 539, + 415, + 552 + ], + "spans": [ + { + "bbox": [ + 115, + 539, + 415, + 552 + ], + "score": 1.0, + "content": "Advances In Neural Information Processing Systems, pp. 613–621, 2016a.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 106, + 557, + 505, + 591 + ], + "lines": [ + { + "bbox": [ + 105, + 556, + 506, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 506, + 571 + ], + "score": 1.0, + "content": "Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Anticipating visual representations from un-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 568, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 115, + 568, + 506, + 581 + ], + "score": 1.0, + "content": "labeled video. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 115, + 579, + 196, + 591 + ], + "spans": [ + { + "bbox": [ + 115, + 579, + 196, + 591 + ], + "score": 1.0, + "content": "pp. 98–106, 2016b.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 106, + 597, + 505, + 631 + ], + "lines": [ + { + "bbox": [ + 105, + 596, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 505, + 611 + ], + "score": 1.0, + "content": "Jacob Walker, Carl Doersch, Abhinav Gupta, and Martial Hebert. An uncertain future: Forecasting", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 609, + 506, + 622 + ], + "spans": [ + { + "bbox": [ + 115, + 609, + 506, + 622 + ], + "score": 1.0, + "content": "from static images using variational autoencoders. In European Conference on Computer Vision,", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 619, + 236, + 632 + ], + "spans": [ + { + "bbox": [ + 115, + 619, + 236, + 632 + ], + "score": 1.0, + "content": "pp. 835–851. Springer, 2016.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 104, + 637, + 504, + 661 + ], + "lines": [ + { + "bbox": [ + 106, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "Xiaolong Wang, Ali Farhadi, and Abhinav Gupta. Actions˜ transformations. In Proceedings of the", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 116, + 649, + 460, + 662 + ], + "spans": [ + { + "bbox": [ + 116, + 649, + 460, + 662 + ], + "score": 1.0, + "content": "IEEE conference on Computer Vision and Pattern Recognition, pp. 2658–2667, 2016.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5 + }, + { + "type": "text", + "bbox": [ + 106, + 667, + 504, + 701 + ], + "lines": [ + { + "bbox": [ + 106, + 666, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 505, + 680 + ], + "score": 1.0, + "content": "Tianfan Xue, Jiajun Wu, Katherine Bouman, and Bill Freeman. Visual dynamics: Probabilistic future", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 677, + 506, + 692 + ], + "spans": [ + { + "bbox": [ + 115, + 677, + 506, + 692 + ], + "score": 1.0, + "content": "frame synthesis via cross convolutional networks. In Advances in Neural Information Processing", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 689, + 222, + 701 + ], + "spans": [ + { + "bbox": [ + 115, + 689, + 222, + 701 + ], + "score": 1.0, + "content": "Systems, pp. 91–99, 2016.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 106, + 707, + 504, + 730 + ], + "lines": [ + { + "bbox": [ + 106, + 707, + 505, + 720 + ], + "spans": [ + { + "bbox": [ + 106, + 707, + 505, + 720 + ], + "score": 1.0, + "content": "Tinghui Zhou, Shubham Tulsiani, Weilun Sun, Jitendra Malik, and Alexei A Efros. View synthesis", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 115, + 718, + 497, + 731 + ], + "spans": [ + { + "bbox": [ + 115, + 718, + 497, + 731 + ], + "score": 1.0, + "content": "by appearance flow. In European conference on computer vision, pp. 286–301. Springer, 2016.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45.5 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 505, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "Jan Hendrik Metzen. Online skill discovery using graph-based clustering. In European Workshop on", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 93, + 288, + 106 + ], + "spans": [ + { + "bbox": [ + 115, + 93, + 288, + 106 + ], + "score": 1.0, + "content": "Reinforcement Learning, pp. 77–88, 2013.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 105, + 81, + 505, + 106 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 111, + 504, + 135 + ], + "lines": [ + { + "bbox": [ + 105, + 110, + 505, + 125 + ], + "spans": [ + { + "bbox": [ + 105, + 110, + 505, + 125 + ], + "score": 1.0, + "content": "Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 123, + 214, + 134 + ], + "spans": [ + { + "bbox": [ + 115, + 123, + 214, + 134 + ], + "score": 1.0, + "content": "arXiv:1411.1784, 2014.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5, + "bbox_fs": [ + 105, + 110, + 505, + 134 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 140, + 504, + 174 + ], + "lines": [ + { + "bbox": [ + 105, + 140, + 506, + 154 + ], + "spans": [ + { + "bbox": [ + 105, + 140, + 506, + 154 + ], + "score": 1.0, + "content": "Hossein Mobahi, Ronan Collobert, and Jason Weston. Deep learning from temporal coherence in", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 150, + 506, + 166 + ], + "spans": [ + { + "bbox": [ + 115, + 150, + 506, + 166 + ], + "score": 1.0, + "content": "video. In Proceedings of the 26th Annual International Conference on Machine Learning, pp.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 162, + 209, + 174 + ], + "spans": [ + { + "bbox": [ + 115, + 162, + 209, + 174 + ], + "score": 1.0, + "content": "737–744. ACM, 2009.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5, + "bbox_fs": [ + 105, + 140, + 506, + 174 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 180, + 504, + 204 + ], + "lines": [ + { + "bbox": [ + 106, + 180, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 106, + 180, + 505, + 194 + ], + "score": 1.0, + "content": "Alexander Neitz, Giambattista Parascandolo, Stefan Bauer, and Bernhard Schlkopf. Adaptive skip", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 192, + 425, + 204 + ], + "spans": [ + { + "bbox": [ + 115, + 192, + 425, + 204 + ], + "score": 1.0, + "content": "intervals: Temporal abstraction for recurrent dynamical models. NIPS, 2018.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5, + "bbox_fs": [ + 106, + 180, + 505, + 204 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 210, + 505, + 244 + ], + "lines": [ + { + "bbox": [ + 106, + 210, + 506, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 210, + 506, + 222 + ], + "score": 1.0, + "content": "Augustus Odena, Vincent Dumoulin, and Chris Olah. Deconvolution and checkerboard arti-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 221, + 506, + 234 + ], + "spans": [ + { + "bbox": [ + 115, + 221, + 506, + 234 + ], + "score": 1.0, + "content": "facts. Distill, 2016. doi: 10.23915/distill.00003. URL http://distill.pub/2016/", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 117, + 234, + 235, + 243 + ], + "spans": [ + { + "bbox": [ + 117, + 234, + 235, + 243 + ], + "score": 1.0, + "content": "deconv-checkerboard.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10, + "bbox_fs": [ + 106, + 210, + 506, + 243 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 250, + 504, + 284 + ], + "lines": [ + { + "bbox": [ + 106, + 250, + 505, + 262 + ], + "spans": [ + { + "bbox": [ + 106, + 250, + 505, + 262 + ], + "score": 1.0, + "content": "Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-conditional", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 260, + 505, + 275 + ], + "spans": [ + { + "bbox": [ + 115, + 260, + 505, + 275 + ], + "score": 1.0, + "content": "video prediction using deep networks in atari games. In Advances in Neural Information Processing", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 115, + 272, + 178, + 285 + ], + "spans": [ + { + "bbox": [ + 115, + 272, + 178, + 285 + ], + "score": 1.0, + "content": "Systems, 2015.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13, + "bbox_fs": [ + 106, + 250, + 505, + 285 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 290, + 505, + 313 + ], + "lines": [ + { + "bbox": [ + 106, + 291, + 505, + 303 + ], + "spans": [ + { + "bbox": [ + 106, + 291, + 505, + 303 + ], + "score": 1.0, + "content": "Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 301, + 279, + 314 + ], + "spans": [ + { + "bbox": [ + 115, + 301, + 279, + 314 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1601.06759, 2016.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5, + "bbox_fs": [ + 106, + 291, + 505, + 314 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 319, + 504, + 343 + ], + "lines": [ + { + "bbox": [ + 106, + 318, + 505, + 334 + ], + "spans": [ + { + "bbox": [ + 106, + 318, + 505, + 334 + ], + "score": 1.0, + "content": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 331, + 468, + 343 + ], + "spans": [ + { + "bbox": [ + 115, + 331, + 468, + 343 + ], + "score": 1.0, + "content": "convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5, + "bbox_fs": [ + 106, + 318, + 505, + 343 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 348, + 505, + 383 + ], + "lines": [ + { + "bbox": [ + 107, + 349, + 505, + 360 + ], + "spans": [ + { + "bbox": [ + 107, + 349, + 505, + 360 + ], + "score": 1.0, + "content": "MarcAurelio Ranzato, Arthur Szlam, Joan Bruna, Michael Mathieu, Ronan Collobert, and Sumit", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 360, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 116, + 360, + 505, + 373 + ], + "score": 1.0, + "content": "Chopra. Video (language) modeling: a baseline for generative models of natural videos. arXiv", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 372, + 249, + 383 + ], + "spans": [ + { + "bbox": [ + 115, + 372, + 249, + 383 + ], + "score": 1.0, + "content": "preprint arXiv:1412.6604, 2014.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20, + "bbox_fs": [ + 107, + 349, + 505, + 383 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 389, + 505, + 412 + ], + "lines": [ + { + "bbox": [ + 106, + 388, + 506, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 388, + 506, + 403 + ], + "score": 1.0, + "content": "Ozg ¨ ur¨ S¸ims¸ek and Andrew G Barto. Skill characterization based on betweenness. In Advances in", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 115, + 400, + 365, + 413 + ], + "spans": [ + { + "bbox": [ + 115, + 400, + 365, + 413 + ], + "score": 1.0, + "content": "neural information processing systems, pp. 1497–1504, 2009.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 106, + 388, + 506, + 413 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 418, + 505, + 442 + ], + "lines": [ + { + "bbox": [ + 106, + 419, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 106, + 419, + 505, + 431 + ], + "score": 1.0, + "content": "Richard S Sutton, Doina Precup, and Satinder Singh. Between mdps and semi-mdps: A framework", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 116, + 429, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 116, + 429, + 506, + 442 + ], + "score": 1.0, + "content": "for temporal abstraction in reinforcement learning. Artificial intelligence, 112(1-2):181–211, 1999.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5, + "bbox_fs": [ + 106, + 419, + 506, + 442 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 447, + 505, + 481 + ], + "lines": [ + { + "bbox": [ + 106, + 447, + 506, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 447, + 506, + 461 + ], + "score": 1.0, + "content": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based con-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 457, + 507, + 474 + ], + "spans": [ + { + "bbox": [ + 115, + 457, + 507, + 474 + ], + "score": 1.0, + "content": "trol. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 470, + 218, + 481 + ], + "spans": [ + { + "bbox": [ + 116, + 470, + 218, + 481 + ], + "score": 1.0, + "content": "5026–5033. IEEE, 2012.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27, + "bbox_fs": [ + 106, + 447, + 507, + 481 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 487, + 504, + 522 + ], + "lines": [ + { + "bbox": [ + 106, + 488, + 506, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 488, + 506, + 500 + ], + "score": 1.0, + "content": "Aaron van den Oord, Nal Kalchbrenner, Lasse Espeholt, Oriol Vinyals, Alex Graves, et al. Conditional", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 499, + 507, + 512 + ], + "spans": [ + { + "bbox": [ + 115, + 499, + 507, + 512 + ], + "score": 1.0, + "content": "image generation with pixelcnn decoders. In Advances in Neural Information Processing Systems,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 511, + 207, + 522 + ], + "spans": [ + { + "bbox": [ + 115, + 511, + 207, + 522 + ], + "score": 1.0, + "content": "pp. 4790–4798, 2016.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30, + "bbox_fs": [ + 106, + 488, + 507, + 522 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 528, + 505, + 551 + ], + "lines": [ + { + "bbox": [ + 105, + 527, + 505, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 505, + 541 + ], + "score": 1.0, + "content": "Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. In", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 539, + 415, + 552 + ], + "spans": [ + { + "bbox": [ + 115, + 539, + 415, + 552 + ], + "score": 1.0, + "content": "Advances In Neural Information Processing Systems, pp. 613–621, 2016a.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 527, + 505, + 552 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 557, + 505, + 591 + ], + "lines": [ + { + "bbox": [ + 105, + 556, + 506, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 506, + 571 + ], + "score": 1.0, + "content": "Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Anticipating visual representations from un-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 568, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 115, + 568, + 506, + 581 + ], + "score": 1.0, + "content": "labeled video. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 115, + 579, + 196, + 591 + ], + "spans": [ + { + "bbox": [ + 115, + 579, + 196, + 591 + ], + "score": 1.0, + "content": "pp. 98–106, 2016b.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 556, + 506, + 591 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 597, + 505, + 631 + ], + "lines": [ + { + "bbox": [ + 105, + 596, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 505, + 611 + ], + "score": 1.0, + "content": "Jacob Walker, Carl Doersch, Abhinav Gupta, and Martial Hebert. An uncertain future: Forecasting", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 609, + 506, + 622 + ], + "spans": [ + { + "bbox": [ + 115, + 609, + 506, + 622 + ], + "score": 1.0, + "content": "from static images using variational autoencoders. In European Conference on Computer Vision,", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 619, + 236, + 632 + ], + "spans": [ + { + "bbox": [ + 115, + 619, + 236, + 632 + ], + "score": 1.0, + "content": "pp. 835–851. Springer, 2016.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 596, + 506, + 632 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 637, + 504, + 661 + ], + "lines": [ + { + "bbox": [ + 106, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "Xiaolong Wang, Ali Farhadi, and Abhinav Gupta. Actions˜ transformations. In Proceedings of the", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 116, + 649, + 460, + 662 + ], + "spans": [ + { + "bbox": [ + 116, + 649, + 460, + 662 + ], + "score": 1.0, + "content": "IEEE conference on Computer Vision and Pattern Recognition, pp. 2658–2667, 2016.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5, + "bbox_fs": [ + 106, + 637, + 505, + 662 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 667, + 504, + 701 + ], + "lines": [ + { + "bbox": [ + 106, + 666, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 505, + 680 + ], + "score": 1.0, + "content": "Tianfan Xue, Jiajun Wu, Katherine Bouman, and Bill Freeman. Visual dynamics: Probabilistic future", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 677, + 506, + 692 + ], + "spans": [ + { + "bbox": [ + 115, + 677, + 506, + 692 + ], + "score": 1.0, + "content": "frame synthesis via cross convolutional networks. In Advances in Neural Information Processing", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 689, + 222, + 701 + ], + "spans": [ + { + "bbox": [ + 115, + 689, + 222, + 701 + ], + "score": 1.0, + "content": "Systems, pp. 91–99, 2016.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43, + "bbox_fs": [ + 106, + 666, + 506, + 701 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 707, + 504, + 730 + ], + "lines": [ + { + "bbox": [ + 106, + 707, + 505, + 720 + ], + "spans": [ + { + "bbox": [ + 106, + 707, + 505, + 720 + ], + "score": 1.0, + "content": "Tinghui Zhou, Shubham Tulsiani, Weilun Sun, Jitendra Malik, and Alexei A Efros. View synthesis", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 115, + 718, + 497, + 731 + ], + "spans": [ + { + "bbox": [ + 115, + 718, + 497, + 731 + ], + "score": 1.0, + "content": "by appearance flow. In European conference on computer vision, pp. 286–301. Springer, 2016.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45.5, + "bbox_fs": [ + 106, + 707, + 505, + 731 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 104, + 80, + 505, + 225 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 104, + 80, + 505, + 225 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 81, + 505, + 224 + ], + "spans": [ + { + "bbox": [ + 104, + 81, + 505, + 224 + ], + "score": 0.962, + "type": "image", + "image_path": "77d54b0e7d23e2a5f211a986f42660665ad7067860e4a9d856ffea03a249a4ba.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 104, + 80, + 505, + 128.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 104, + 128.33333333333334, + 505, + 176.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 104, + 176.66666666666669, + 505, + 225.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 233, + 505, + 254 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 232, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 106, + 232, + 380, + 245 + ], + "score": 1.0, + "content": "Figure 11: Training time network schematic. At test time, only the predictor", + "type": "text" + }, + { + "bbox": [ + 380, + 234, + 388, + 243 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 232, + 433, + 245 + ], + "score": 1.0, + "content": "is used, and", + "type": "text" + }, + { + "bbox": [ + 433, + 233, + 482, + 244 + ], + "score": 0.92, + "content": "z \\sim \\mathcal { N } ( 0 , \\mathcal { Z } )", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 232, + 505, + 245 + ], + "score": 1.0, + "content": ". Loss", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 243, + 234, + 254 + ], + "spans": [ + { + "bbox": [ + 106, + 243, + 234, + 254 + ], + "score": 1.0, + "content": "terms (as used in Eq 10) are in red.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 107, + 263, + 506, + 297 + ], + "lines": [ + { + "bbox": [ + 105, + 262, + 506, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 506, + 276 + ], + "score": 1.0, + "content": "In these appendices, we provide details omitted in the main text for space. Note that more supple-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 275, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 106, + 275, + 505, + 286 + ], + "score": 1.0, + "content": "mentary material, such as video examples, is hosted at: https://sites.google.com/view/", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 286, + 153, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 153, + 297 + ], + "score": 1.0, + "content": "ta-pred", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "title", + "bbox": [ + 105, + 311, + 457, + 325 + ], + "lines": [ + { + "bbox": [ + 106, + 311, + 458, + 326 + ], + "spans": [ + { + "bbox": [ + 106, + 311, + 458, + 326 + ], + "score": 1.0, + "content": "A LABEL SMOOTHING FOR TIME-AGNOSTIC CONDITIONAL GANS", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 334, + 505, + 390 + ], + "lines": [ + { + "bbox": [ + 105, + 334, + 505, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 117, + 348 + ], + "score": 1.0, + "content": "In", + "type": "text" + }, + { + "bbox": [ + 117, + 335, + 137, + 347 + ], + "score": 0.3, + "content": "\\operatorname { E q } 7", + "type": "inline_equation" + }, + { + "bbox": [ + 137, + 334, + 346, + 348 + ], + "score": 1.0, + "content": ", we defined a time-agnostic CGAN loss that trained", + "type": "text" + }, + { + "bbox": [ + 347, + 335, + 356, + 345 + ], + "score": 0.39, + "content": "\\mathrm { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 334, + 505, + 348 + ], + "score": 1.0, + "content": "discriminators, one corresponding to", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 344, + 505, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 173, + 358 + ], + "score": 1.0, + "content": "each target time", + "type": "text" + }, + { + "bbox": [ + 174, + 346, + 198, + 356 + ], + "score": 0.89, + "content": "t \\in \\mathrm { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 199, + 344, + 341, + 358 + ], + "score": 1.0, + "content": ". In Eq 7, the only positives for the", + "type": "text" + }, + { + "bbox": [ + 341, + 347, + 346, + 356 + ], + "score": 0.78, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 344, + 415, + 358 + ], + "score": 1.0, + "content": "-th discriminator", + "type": "text" + }, + { + "bbox": [ + 416, + 346, + 428, + 357 + ], + "score": 0.89, + "content": "D _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 344, + 505, + 358 + ], + "score": 1.0, + "content": "were ground truth", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 357, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 106, + 357, + 257, + 369 + ], + "score": 1.0, + "content": "frames that occured precisely at time", + "type": "text" + }, + { + "bbox": [ + 257, + 358, + 262, + 367 + ], + "score": 0.8, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 357, + 344, + 369 + ], + "score": 1.0, + "content": "relative to the input", + "type": "text" + }, + { + "bbox": [ + 344, + 359, + 350, + 367 + ], + "score": 0.72, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 350, + 357, + 505, + 369 + ], + "score": 1.0, + "content": ", i.e., discriminators are trained so that", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 107, + 366, + 506, + 381 + ], + "spans": [ + { + "bbox": [ + 107, + 367, + 145, + 380 + ], + "score": 0.93, + "content": "D _ { t } ( c , x _ { t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 366, + 213, + 381 + ], + "score": 1.0, + "content": "would be 1, and", + "type": "text" + }, + { + "bbox": [ + 213, + 368, + 263, + 380 + ], + "score": 0.92, + "content": "D _ { t } ( c , x _ { t ^ { \\prime } \\neq t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 366, + 281, + 381 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 282, + 367, + 331, + 380 + ], + "score": 0.93, + "content": "D _ { t } ( c , G ( c ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 366, + 506, + 381 + ], + "score": 1.0, + "content": "would both be 0. However, in practice, we", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 378, + 267, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 267, + 391 + ], + "score": 1.0, + "content": "use the following slightly different loss:", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11 + }, + { + "type": "interline_equation", + "bbox": [ + 140, + 391, + 470, + 458 + ], + "lines": [ + { + "bbox": [ + 140, + 391, + 470, + 458 + ], + "spans": [ + { + "bbox": [ + 140, + 391, + 470, + 458 + ], + "score": 0.93, + "content": "\\begin{array} { r l } & { G ^ { * } = \\underset { G } { \\arg \\operatorname* { m i n } } \\underset { t \\in \\mathcal { T } } { \\min } \\underset { D _ { t } } { \\operatorname* { m a x } } \\mathcal { L } _ { \\mathrm { c g a n } } ^ { t } ( G , D _ { t } ) , } \\\\ & { \\mathcal { L } _ { \\mathrm { c g a n } } ^ { t } ( G , D _ { t } ) = \\log D _ { t } ( c , x _ { t } ) + \\log ( 1 - D _ { t } ( c , G ( c ) ) ) + } \\\\ & { \\qquad \\quad \\sum _ { t ^ { \\prime } \\not = t } [ l _ { t , t ^ { \\prime } } \\log D _ { t } ( c , x _ { t ^ { \\prime } } ) + ( 1 - l _ { t , t ^ { \\prime } } ) \\log ( 1 - D _ { t } ( c , x _ { t ^ { \\prime } } ) ) ] , } \\end{array}", + "type": "interline_equation", + "image_path": "4525ffd75e604ae849a8afb8894be0951568926697e2a3b057606d386734f216.jpg" + } + ] + } + ], + "index": 15, + "virtual_lines": [ + { + "bbox": [ + 140, + 391, + 470, + 413.3333333333333 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 140, + 413.3333333333333, + 470, + 435.66666666666663 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 140, + 435.66666666666663, + 470, + 457.99999999999994 + ], + "spans": [], + "index": 16 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 460, + 505, + 517 + ], + "lines": [ + { + "bbox": [ + 106, + 461, + 505, + 473 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 161, + 473 + ], + "score": 1.0, + "content": "where we set", + "type": "text" + }, + { + "bbox": [ + 162, + 461, + 277, + 473 + ], + "score": 0.92, + "content": "l _ { t , t ^ { \\prime } } = \\operatorname* { m a x } ( 0 , 1 - \\alpha | t - t ^ { \\prime } | )", + "type": "inline_equation" + }, + { + "bbox": [ + 277, + 461, + 299, + 473 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 299, + 461, + 338, + 472 + ], + "score": 0.88, + "content": "\\alpha = 0 . 2 5", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 461, + 484, + 473 + ], + "score": 1.0, + "content": ". The first two terms are the same as", + "type": "text" + }, + { + "bbox": [ + 484, + 462, + 505, + 473 + ], + "score": 0.34, + "content": "\\mathrm { E q } ~ 7", + "type": "inline_equation" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 472, + 506, + 485 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 146, + 485 + ], + "score": 1.0, + "content": "— for the", + "type": "text" + }, + { + "bbox": [ + 146, + 473, + 151, + 482 + ], + "score": 0.75, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 472, + 236, + 485 + ], + "score": 1.0, + "content": "-th discriminator, the", + "type": "text" + }, + { + "bbox": [ + 237, + 474, + 242, + 482 + ], + "score": 0.76, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 472, + 506, + 485 + ], + "score": 1.0, + "content": "-th frame provides a positive, and the generated frame provides a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 347, + 496 + ], + "score": 1.0, + "content": "negative instance. The third term defines the loss for frames", + "type": "text" + }, + { + "bbox": [ + 347, + 485, + 369, + 496 + ], + "score": 0.88, + "content": "x _ { t ^ { \\prime } \\neq t }", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 483, + 456, + 496 + ], + "score": 1.0, + "content": ": frames close to time", + "type": "text" + }, + { + "bbox": [ + 457, + 485, + 461, + 493 + ], + "score": 0.78, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 461, + 483, + 506, + 496 + ], + "score": 1.0, + "content": "are partial", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 492, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 146, + 509 + ], + "score": 1.0, + "content": "positives", + "type": "text" + }, + { + "bbox": [ + 146, + 495, + 201, + 506 + ], + "score": 0.89, + "content": "( 0 < l _ { t , t ^ { \\prime } } < 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 492, + 304, + 509 + ], + "score": 1.0, + "content": ", and others are negatives", + "type": "text" + }, + { + "bbox": [ + 304, + 495, + 342, + 506 + ], + "score": 0.86, + "content": "( l _ { t , t ^ { \\prime } } = 0 )", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 492, + 506, + 509 + ], + "score": 1.0, + "content": ". This label smoothing stabilizes training", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 505, + 332, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 316, + 518 + ], + "score": 1.0, + "content": "and ensures enough positives for each discriminator", + "type": "text" + }, + { + "bbox": [ + 316, + 506, + 328, + 516 + ], + "score": 0.88, + "content": "D _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 329, + 505, + 332, + 518 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19 + }, + { + "type": "title", + "bbox": [ + 107, + 532, + 325, + 545 + ], + "lines": [ + { + "bbox": [ + 105, + 531, + 326, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 326, + 547 + ], + "score": 1.0, + "content": "B TIME-AGNOSTIC CONDITIONAL VAES", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 106, + 556, + 505, + 601 + ], + "lines": [ + { + "bbox": [ + 106, + 557, + 506, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 557, + 376, + 569 + ], + "score": 1.0, + "content": "Here, we discuss one alternative to the TAP CVAE formulation of", + "type": "text" + }, + { + "bbox": [ + 376, + 557, + 396, + 568 + ], + "score": 0.42, + "content": "\\operatorname { E q } 9", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 557, + 506, + 569 + ], + "score": 1.0, + "content": "in Sec 3.4. Rather than re-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 568, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 505, + 579 + ], + "score": 1.0, + "content": "stricting the minimum-over-time to be over the log-likelihood term alone, why not take the minimum-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 579, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 505, + 591 + ], + "score": 1.0, + "content": "over-time over the whole loss? In other words, the inference network would still have to only see one", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 590, + 368, + 601 + ], + "spans": [ + { + "bbox": [ + 106, + 590, + 368, + 601 + ], + "score": 1.0, + "content": "frame as input, and this version of the TAP CVAE loss would be:", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 24.5 + }, + { + "type": "interline_equation", + "bbox": [ + 158, + 603, + 452, + 622 + ], + "lines": [ + { + "bbox": [ + 158, + 603, + 452, + 622 + ], + "spans": [ + { + "bbox": [ + 158, + 603, + 452, + 622 + ], + "score": 0.91, + "content": "\\mathcal { L } _ { \\mathrm { c v a e } } ( G , \\phi ) = \\operatorname* { m i n } _ { t \\in \\mathbb { T } } \\left[ D _ { K L } ( q _ { \\phi } ( z | x _ { t } ) , p ( z ) ) - \\mathbb { E } _ { z \\sim q _ { \\phi } ( z | x _ { t } ) } \\ln p _ { G } ( x _ { t } | c , z ) \\right] .", + "type": "interline_equation", + "image_path": "96ba7cbc5c034d740ad55663a0ae632523b6d30631ac44d8d0bbbef5eaf52d26.jpg" + } + ] + } + ], + "index": 27, + "virtual_lines": [ + { + "bbox": [ + 158, + 603, + 452, + 622 + ], + "spans": [], + "index": 27 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 625, + 505, + 669 + ], + "lines": [ + { + "bbox": [ + 105, + 624, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 506, + 637 + ], + "score": 1.0, + "content": "Unfortunately, this would be computationally very expensive to train. Both the inference network", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 107, + 636, + 504, + 649 + ], + "spans": [ + { + "bbox": [ + 107, + 638, + 117, + 649 + ], + "score": 0.82, + "content": "q _ { \\phi }", + "type": "inline_equation" + }, + { + "bbox": [ + 118, + 636, + 192, + 649 + ], + "score": 1.0, + "content": "and the generator", + "type": "text" + }, + { + "bbox": [ + 192, + 637, + 201, + 646 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 636, + 295, + 649 + ], + "score": 1.0, + "content": "would have to process", + "type": "text" + }, + { + "bbox": [ + 295, + 636, + 309, + 648 + ], + "score": 0.79, + "content": "| \\mathrm { T } |", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 636, + 483, + 649 + ], + "score": 1.0, + "content": "frames. In comparison, the formulation of", + "type": "text" + }, + { + "bbox": [ + 484, + 636, + 504, + 648 + ], + "score": 0.41, + "content": "\\operatorname { E q } 9", + "type": "inline_equation" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 646, + 506, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 135, + 660 + ], + "score": 1.0, + "content": "allows", + "type": "text" + }, + { + "bbox": [ + 135, + 649, + 146, + 659 + ], + "score": 0.86, + "content": "q _ { \\phi }", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 646, + 164, + 660 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 164, + 647, + 173, + 657 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 646, + 447, + 660 + ], + "score": 1.0, + "content": "to process just one frame, and only error computation must be done", + "type": "text" + }, + { + "bbox": [ + 447, + 648, + 456, + 657 + ], + "score": 0.48, + "content": "\\mathrm { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 646, + 506, + 660 + ], + "score": 1.0, + "content": "times, once", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 658, + 251, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 197, + 670 + ], + "score": 1.0, + "content": "with each target frame", + "type": "text" + }, + { + "bbox": [ + 198, + 659, + 208, + 669 + ], + "score": 0.84, + "content": "x _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 209, + 658, + 223, + 670 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 224, + 658, + 248, + 668 + ], + "score": 0.89, + "content": "t \\in \\mathrm { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 658, + 251, + 670 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5 + }, + { + "type": "title", + "bbox": [ + 107, + 685, + 336, + 698 + ], + "lines": [ + { + "bbox": [ + 105, + 684, + 336, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 684, + 336, + 700 + ], + "score": 1.0, + "content": "C ARCHITECTURE AND TRAINING DETAILS", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 353, + 722 + ], + "score": 1.0, + "content": "Predictor architecture. As indicated in Fig 11, the predictor", + "type": "text" + }, + { + "bbox": [ + 353, + 712, + 362, + 720 + ], + "score": 0.86, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "has an encoder-decoder architecture.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 720, + 504, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 497, + 732 + ], + "score": 1.0, + "content": "When our approach is used together with the conditional VAE (Sec 3.4), the conditional latent", + "type": "text" + }, + { + "bbox": [ + 497, + 722, + 504, + 730 + ], + "score": 0.71, + "content": "z", + "type": "inline_equation" + } + ], + "index": 34 + } + ], + "index": 33.5 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "12", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 104, + 80, + 505, + 225 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 104, + 80, + 505, + 225 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 81, + 505, + 224 + ], + "spans": [ + { + "bbox": [ + 104, + 81, + 505, + 224 + ], + "score": 0.962, + "type": "image", + "image_path": "77d54b0e7d23e2a5f211a986f42660665ad7067860e4a9d856ffea03a249a4ba.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 104, + 80, + 505, + 128.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 104, + 128.33333333333334, + 505, + 176.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 104, + 176.66666666666669, + 505, + 225.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 233, + 505, + 254 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 232, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 106, + 232, + 380, + 245 + ], + "score": 1.0, + "content": "Figure 11: Training time network schematic. At test time, only the predictor", + "type": "text" + }, + { + "bbox": [ + 380, + 234, + 388, + 243 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 232, + 433, + 245 + ], + "score": 1.0, + "content": "is used, and", + "type": "text" + }, + { + "bbox": [ + 433, + 233, + 482, + 244 + ], + "score": 0.92, + "content": "z \\sim \\mathcal { N } ( 0 , \\mathcal { Z } )", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 232, + 505, + 245 + ], + "score": 1.0, + "content": ". Loss", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 243, + 234, + 254 + ], + "spans": [ + { + "bbox": [ + 106, + 243, + 234, + 254 + ], + "score": 1.0, + "content": "terms (as used in Eq 10) are in red.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 107, + 263, + 506, + 297 + ], + "lines": [ + { + "bbox": [ + 105, + 262, + 506, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 506, + 276 + ], + "score": 1.0, + "content": "In these appendices, we provide details omitted in the main text for space. Note that more supple-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 275, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 106, + 275, + 505, + 286 + ], + "score": 1.0, + "content": "mentary material, such as video examples, is hosted at: https://sites.google.com/view/", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 286, + 153, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 153, + 297 + ], + "score": 1.0, + "content": "ta-pred", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6, + "bbox_fs": [ + 105, + 262, + 506, + 297 + ] + }, + { + "type": "title", + "bbox": [ + 105, + 311, + 457, + 325 + ], + "lines": [ + { + "bbox": [ + 106, + 311, + 458, + 326 + ], + "spans": [ + { + "bbox": [ + 106, + 311, + 458, + 326 + ], + "score": 1.0, + "content": "A LABEL SMOOTHING FOR TIME-AGNOSTIC CONDITIONAL GANS", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 334, + 505, + 390 + ], + "lines": [ + { + "bbox": [ + 105, + 334, + 505, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 117, + 348 + ], + "score": 1.0, + "content": "In", + "type": "text" + }, + { + "bbox": [ + 117, + 335, + 137, + 347 + ], + "score": 0.3, + "content": "\\operatorname { E q } 7", + "type": "inline_equation" + }, + { + "bbox": [ + 137, + 334, + 346, + 348 + ], + "score": 1.0, + "content": ", we defined a time-agnostic CGAN loss that trained", + "type": "text" + }, + { + "bbox": [ + 347, + 335, + 356, + 345 + ], + "score": 0.39, + "content": "\\mathrm { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 334, + 505, + 348 + ], + "score": 1.0, + "content": "discriminators, one corresponding to", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 344, + 505, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 173, + 358 + ], + "score": 1.0, + "content": "each target time", + "type": "text" + }, + { + "bbox": [ + 174, + 346, + 198, + 356 + ], + "score": 0.89, + "content": "t \\in \\mathrm { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 199, + 344, + 341, + 358 + ], + "score": 1.0, + "content": ". In Eq 7, the only positives for the", + "type": "text" + }, + { + "bbox": [ + 341, + 347, + 346, + 356 + ], + "score": 0.78, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 344, + 415, + 358 + ], + "score": 1.0, + "content": "-th discriminator", + "type": "text" + }, + { + "bbox": [ + 416, + 346, + 428, + 357 + ], + "score": 0.89, + "content": "D _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 344, + 505, + 358 + ], + "score": 1.0, + "content": "were ground truth", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 357, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 106, + 357, + 257, + 369 + ], + "score": 1.0, + "content": "frames that occured precisely at time", + "type": "text" + }, + { + "bbox": [ + 257, + 358, + 262, + 367 + ], + "score": 0.8, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 357, + 344, + 369 + ], + "score": 1.0, + "content": "relative to the input", + "type": "text" + }, + { + "bbox": [ + 344, + 359, + 350, + 367 + ], + "score": 0.72, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 350, + 357, + 505, + 369 + ], + "score": 1.0, + "content": ", i.e., discriminators are trained so that", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 107, + 366, + 506, + 381 + ], + "spans": [ + { + "bbox": [ + 107, + 367, + 145, + 380 + ], + "score": 0.93, + "content": "D _ { t } ( c , x _ { t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 366, + 213, + 381 + ], + "score": 1.0, + "content": "would be 1, and", + "type": "text" + }, + { + "bbox": [ + 213, + 368, + 263, + 380 + ], + "score": 0.92, + "content": "D _ { t } ( c , x _ { t ^ { \\prime } \\neq t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 366, + 281, + 381 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 282, + 367, + 331, + 380 + ], + "score": 0.93, + "content": "D _ { t } ( c , G ( c ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 366, + 506, + 381 + ], + "score": 1.0, + "content": "would both be 0. However, in practice, we", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 378, + 267, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 267, + 391 + ], + "score": 1.0, + "content": "use the following slightly different loss:", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11, + "bbox_fs": [ + 105, + 334, + 506, + 391 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 140, + 391, + 470, + 458 + ], + "lines": [ + { + "bbox": [ + 140, + 391, + 470, + 458 + ], + "spans": [ + { + "bbox": [ + 140, + 391, + 470, + 458 + ], + "score": 0.93, + "content": "\\begin{array} { r l } & { G ^ { * } = \\underset { G } { \\arg \\operatorname* { m i n } } \\underset { t \\in \\mathcal { T } } { \\min } \\underset { D _ { t } } { \\operatorname* { m a x } } \\mathcal { L } _ { \\mathrm { c g a n } } ^ { t } ( G , D _ { t } ) , } \\\\ & { \\mathcal { L } _ { \\mathrm { c g a n } } ^ { t } ( G , D _ { t } ) = \\log D _ { t } ( c , x _ { t } ) + \\log ( 1 - D _ { t } ( c , G ( c ) ) ) + } \\\\ & { \\qquad \\quad \\sum _ { t ^ { \\prime } \\not = t } [ l _ { t , t ^ { \\prime } } \\log D _ { t } ( c , x _ { t ^ { \\prime } } ) + ( 1 - l _ { t , t ^ { \\prime } } ) \\log ( 1 - D _ { t } ( c , x _ { t ^ { \\prime } } ) ) ] , } \\end{array}", + "type": "interline_equation", + "image_path": "4525ffd75e604ae849a8afb8894be0951568926697e2a3b057606d386734f216.jpg" + } + ] + } + ], + "index": 15, + "virtual_lines": [ + { + "bbox": [ + 140, + 391, + 470, + 413.3333333333333 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 140, + 413.3333333333333, + 470, + 435.66666666666663 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 140, + 435.66666666666663, + 470, + 457.99999999999994 + ], + "spans": [], + "index": 16 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 460, + 505, + 517 + ], + "lines": [ + { + "bbox": [ + 106, + 461, + 505, + 473 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 161, + 473 + ], + "score": 1.0, + "content": "where we set", + "type": "text" + }, + { + "bbox": [ + 162, + 461, + 277, + 473 + ], + "score": 0.92, + "content": "l _ { t , t ^ { \\prime } } = \\operatorname* { m a x } ( 0 , 1 - \\alpha | t - t ^ { \\prime } | )", + "type": "inline_equation" + }, + { + "bbox": [ + 277, + 461, + 299, + 473 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 299, + 461, + 338, + 472 + ], + "score": 0.88, + "content": "\\alpha = 0 . 2 5", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 461, + 484, + 473 + ], + "score": 1.0, + "content": ". The first two terms are the same as", + "type": "text" + }, + { + "bbox": [ + 484, + 462, + 505, + 473 + ], + "score": 0.34, + "content": "\\mathrm { E q } ~ 7", + "type": "inline_equation" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 472, + 506, + 485 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 146, + 485 + ], + "score": 1.0, + "content": "— for the", + "type": "text" + }, + { + "bbox": [ + 146, + 473, + 151, + 482 + ], + "score": 0.75, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 472, + 236, + 485 + ], + "score": 1.0, + "content": "-th discriminator, the", + "type": "text" + }, + { + "bbox": [ + 237, + 474, + 242, + 482 + ], + "score": 0.76, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 472, + 506, + 485 + ], + "score": 1.0, + "content": "-th frame provides a positive, and the generated frame provides a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 347, + 496 + ], + "score": 1.0, + "content": "negative instance. The third term defines the loss for frames", + "type": "text" + }, + { + "bbox": [ + 347, + 485, + 369, + 496 + ], + "score": 0.88, + "content": "x _ { t ^ { \\prime } \\neq t }", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 483, + 456, + 496 + ], + "score": 1.0, + "content": ": frames close to time", + "type": "text" + }, + { + "bbox": [ + 457, + 485, + 461, + 493 + ], + "score": 0.78, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 461, + 483, + 506, + 496 + ], + "score": 1.0, + "content": "are partial", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 492, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 146, + 509 + ], + "score": 1.0, + "content": "positives", + "type": "text" + }, + { + "bbox": [ + 146, + 495, + 201, + 506 + ], + "score": 0.89, + "content": "( 0 < l _ { t , t ^ { \\prime } } < 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 492, + 304, + 509 + ], + "score": 1.0, + "content": ", and others are negatives", + "type": "text" + }, + { + "bbox": [ + 304, + 495, + 342, + 506 + ], + "score": 0.86, + "content": "( l _ { t , t ^ { \\prime } } = 0 )", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 492, + 506, + 509 + ], + "score": 1.0, + "content": ". This label smoothing stabilizes training", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 505, + 332, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 316, + 518 + ], + "score": 1.0, + "content": "and ensures enough positives for each discriminator", + "type": "text" + }, + { + "bbox": [ + 316, + 506, + 328, + 516 + ], + "score": 0.88, + "content": "D _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 329, + 505, + 332, + 518 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19, + "bbox_fs": [ + 105, + 461, + 506, + 518 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 532, + 325, + 545 + ], + "lines": [ + { + "bbox": [ + 105, + 531, + 326, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 326, + 547 + ], + "score": 1.0, + "content": "B TIME-AGNOSTIC CONDITIONAL VAES", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 106, + 556, + 505, + 601 + ], + "lines": [ + { + "bbox": [ + 106, + 557, + 506, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 557, + 376, + 569 + ], + "score": 1.0, + "content": "Here, we discuss one alternative to the TAP CVAE formulation of", + "type": "text" + }, + { + "bbox": [ + 376, + 557, + 396, + 568 + ], + "score": 0.42, + "content": "\\operatorname { E q } 9", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 557, + 506, + 569 + ], + "score": 1.0, + "content": "in Sec 3.4. Rather than re-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 568, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 505, + 579 + ], + "score": 1.0, + "content": "stricting the minimum-over-time to be over the log-likelihood term alone, why not take the minimum-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 579, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 505, + 591 + ], + "score": 1.0, + "content": "over-time over the whole loss? In other words, the inference network would still have to only see one", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 590, + 368, + 601 + ], + "spans": [ + { + "bbox": [ + 106, + 590, + 368, + 601 + ], + "score": 1.0, + "content": "frame as input, and this version of the TAP CVAE loss would be:", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 24.5, + "bbox_fs": [ + 105, + 557, + 506, + 601 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 158, + 603, + 452, + 622 + ], + "lines": [ + { + "bbox": [ + 158, + 603, + 452, + 622 + ], + "spans": [ + { + "bbox": [ + 158, + 603, + 452, + 622 + ], + "score": 0.91, + "content": "\\mathcal { L } _ { \\mathrm { c v a e } } ( G , \\phi ) = \\operatorname* { m i n } _ { t \\in \\mathbb { T } } \\left[ D _ { K L } ( q _ { \\phi } ( z | x _ { t } ) , p ( z ) ) - \\mathbb { E } _ { z \\sim q _ { \\phi } ( z | x _ { t } ) } \\ln p _ { G } ( x _ { t } | c , z ) \\right] .", + "type": "interline_equation", + "image_path": "96ba7cbc5c034d740ad55663a0ae632523b6d30631ac44d8d0bbbef5eaf52d26.jpg" + } + ] + } + ], + "index": 27, + "virtual_lines": [ + { + "bbox": [ + 158, + 603, + 452, + 622 + ], + "spans": [], + "index": 27 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 625, + 505, + 669 + ], + "lines": [ + { + "bbox": [ + 105, + 624, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 506, + 637 + ], + "score": 1.0, + "content": "Unfortunately, this would be computationally very expensive to train. Both the inference network", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 107, + 636, + 504, + 649 + ], + "spans": [ + { + "bbox": [ + 107, + 638, + 117, + 649 + ], + "score": 0.82, + "content": "q _ { \\phi }", + "type": "inline_equation" + }, + { + "bbox": [ + 118, + 636, + 192, + 649 + ], + "score": 1.0, + "content": "and the generator", + "type": "text" + }, + { + "bbox": [ + 192, + 637, + 201, + 646 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 636, + 295, + 649 + ], + "score": 1.0, + "content": "would have to process", + "type": "text" + }, + { + "bbox": [ + 295, + 636, + 309, + 648 + ], + "score": 0.79, + "content": "| \\mathrm { T } |", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 636, + 483, + 649 + ], + "score": 1.0, + "content": "frames. In comparison, the formulation of", + "type": "text" + }, + { + "bbox": [ + 484, + 636, + 504, + 648 + ], + "score": 0.41, + "content": "\\operatorname { E q } 9", + "type": "inline_equation" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 646, + 506, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 135, + 660 + ], + "score": 1.0, + "content": "allows", + "type": "text" + }, + { + "bbox": [ + 135, + 649, + 146, + 659 + ], + "score": 0.86, + "content": "q _ { \\phi }", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 646, + 164, + 660 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 164, + 647, + 173, + 657 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 646, + 447, + 660 + ], + "score": 1.0, + "content": "to process just one frame, and only error computation must be done", + "type": "text" + }, + { + "bbox": [ + 447, + 648, + 456, + 657 + ], + "score": 0.48, + "content": "\\mathrm { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 646, + 506, + 660 + ], + "score": 1.0, + "content": "times, once", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 658, + 251, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 197, + 670 + ], + "score": 1.0, + "content": "with each target frame", + "type": "text" + }, + { + "bbox": [ + 198, + 659, + 208, + 669 + ], + "score": 0.84, + "content": "x _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 209, + 658, + 223, + 670 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 224, + 658, + 248, + 668 + ], + "score": 0.89, + "content": "t \\in \\mathrm { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 658, + 251, + 670 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5, + "bbox_fs": [ + 105, + 624, + 506, + 670 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 685, + 336, + 698 + ], + "lines": [ + { + "bbox": [ + 105, + 684, + 336, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 684, + 336, + 700 + ], + "score": 1.0, + "content": "C ARCHITECTURE AND TRAINING DETAILS", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 353, + 722 + ], + "score": 1.0, + "content": "Predictor architecture. As indicated in Fig 11, the predictor", + "type": "text" + }, + { + "bbox": [ + 353, + 712, + 362, + 720 + ], + "score": 0.86, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "has an encoder-decoder architecture.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 720, + 504, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 497, + 732 + ], + "score": 1.0, + "content": "When our approach is used together with the conditional VAE (Sec 3.4), the conditional latent", + "type": "text" + }, + { + "bbox": [ + 497, + 722, + 504, + 730 + ], + "score": 0.71, + "content": "z", + "type": "inline_equation" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 215, + 506, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 215, + 506, + 227 + ], + "score": 1.0, + "content": "is appended at the bottleneck between the encoder and the decoder. The encoder produces a 128-", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 226, + 505, + 237 + ], + "spans": [ + { + "bbox": [ + 106, + 226, + 277, + 237 + ], + "score": 1.0, + "content": "dimensional code, and the VAE latent code", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 277, + 228, + 284, + 236 + ], + "score": 0.76, + "content": "z", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 285, + 226, + 505, + 237 + ], + "score": 1.0, + "content": "is 32-dimensional, so the overall size of the input to the", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 237, + 259, + 248 + ], + "spans": [ + { + "bbox": [ + 106, + 237, + 259, + 248 + ], + "score": 1.0, + "content": "decoder is 160 when the VAE is used.", + "type": "text", + "cross_page": true + } + ], + "index": 7 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 709, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 135, + 78, + 477, + 168 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 135, + 78, + 477, + 168 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 135, + 78, + 477, + 168 + ], + "spans": [ + { + "bbox": [ + 135, + 78, + 477, + 168 + ], + "score": 0.968, + "type": "image", + "image_path": "f8856cd9f2f3798eee429753195214b113ada59861c91af370862789af7f7cd3.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 135, + 78, + 477, + 108.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 135, + 108.0, + 477, + 138.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 135, + 138.0, + 477, + 168.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 177, + 505, + 198 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 176, + 506, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 506, + 189 + ], + "score": 1.0, + "content": "Figure 12: The predictor produces an appearance flowfield which is used to produce flow-warped input frames,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 187, + 456, + 198 + ], + "spans": [ + { + "bbox": [ + 106, + 187, + 456, + 198 + ], + "score": 1.0, + "content": "which together with a frame of new pixels are masked and averaged to produce the output frame.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 107, + 215, + 505, + 248 + ], + "lines": [ + { + "bbox": [ + 105, + 215, + 506, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 215, + 506, + 227 + ], + "score": 1.0, + "content": "is appended at the bottleneck between the encoder and the decoder. The encoder produces a 128-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 226, + 505, + 237 + ], + "spans": [ + { + "bbox": [ + 106, + 226, + 277, + 237 + ], + "score": 1.0, + "content": "dimensional code, and the VAE latent code", + "type": "text" + }, + { + "bbox": [ + 277, + 228, + 284, + 236 + ], + "score": 0.76, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 226, + 505, + 237 + ], + "score": 1.0, + "content": "is 32-dimensional, so the overall size of the input to the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 237, + 259, + 248 + ], + "spans": [ + { + "bbox": [ + 106, + 237, + 259, + 248 + ], + "score": 1.0, + "content": "decoder is 160 when the VAE is used.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 254, + 505, + 320 + ], + "lines": [ + { + "bbox": [ + 106, + 254, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 106, + 254, + 505, + 267 + ], + "score": 1.0, + "content": "The encoder inside the predictor uses a series of 4x4convolution-batchnorm-LeakyReLU(0.2) blocks", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 265, + 506, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 253, + 277 + ], + "score": 1.0, + "content": "to reduce the 64x64 input image as", + "type": "text" + }, + { + "bbox": [ + 253, + 265, + 483, + 276 + ], + "score": 0.83, + "content": "3 \\mathrm { x 6 4 \\mathrm { x 6 4 } } { } 3 2 \\mathrm { x } 3 2 \\mathrm { x } 3 2 { } 6 4 \\mathrm { x } 1 6 \\mathrm { x } 1 6 { } 1 2 8 \\mathrm { x } 8 \\mathrm { x } 8 { } 2 5 6 \\mathrm { x } 4 \\mathrm { x } 4", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 265, + 506, + 277 + ], + "score": 1.0, + "content": ". For", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 276, + 504, + 288 + ], + "spans": [ + { + "bbox": [ + 106, + 276, + 466, + 288 + ], + "score": 1.0, + "content": "bidirectional prediction, this is repeated for both images and concatenated to produce a", + "type": "text" + }, + { + "bbox": [ + 467, + 276, + 504, + 286 + ], + "score": 0.71, + "content": "5 1 2 \\mathrm { x } 4 \\mathrm { x } 4", + "type": "inline_equation" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 287, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 106, + 287, + 505, + 298 + ], + "score": 1.0, + "content": "feature map. Finally, a small convolution-ReLU-convolution head reduces this to a 128-dimensional", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 298, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 106, + 298, + 506, + 310 + ], + "score": 1.0, + "content": "vector. Except for this last head subnetwork, this architecture is identical to the DCGAN discrimina-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 309, + 210, + 320 + ], + "spans": [ + { + "bbox": [ + 106, + 309, + 210, + 320 + ], + "score": 1.0, + "content": "tor (Radford et al., 2015).", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 107, + 325, + 505, + 403 + ], + "lines": [ + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "The decoder inside the predictor uses a DCGAN-based architecture (Radford et al., 2015).", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 336, + 507, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 391, + 350 + ], + "score": 1.0, + "content": "The input vector is reshaped by a transposed convolution into 256", + "type": "text" + }, + { + "bbox": [ + 392, + 337, + 412, + 347 + ], + "score": 0.61, + "content": "4 \\times 4", + "type": "inline_equation" + }, + { + "bbox": [ + 412, + 336, + 507, + 350 + ], + "score": 1.0, + "content": "maps. This is subse-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 347, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 506, + 361 + ], + "score": 1.0, + "content": "quently processed a series of bilinear upsampling-5x5convolution-batchnorm-ReLU blocks as", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 358, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 106, + 358, + 285, + 369 + ], + "score": 0.91, + "content": "2 5 6 \\times 4 \\times 4 - 1 2 8 \\times 8 \\times 8 6 4 \\mathrm { x } 3 2 \\mathrm { x } 3 2 3 \\mathrm { x } 6 4 \\mathrm { x } \\bar { 6 } 4", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 358, + 505, + 371 + ], + "score": 1.0, + "content": ". For the last block, a Tanh activation is used in place", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 370, + 505, + 382 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 505, + 382 + ], + "score": 1.0, + "content": "of ReLU to keep outputs in [-1,1]. Compared to (Radford et al., 2015), the main difference is that", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 381, + 506, + 393 + ], + "spans": [ + { + "bbox": [ + 106, + 381, + 506, + 393 + ], + "score": 1.0, + "content": "transposed convolutions are replaced by upsampling-5x5 convolution blocks, which aids in faster", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 392, + 333, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 333, + 404 + ], + "score": 1.0, + "content": "learning with fewer image artifacts (Odena et al., 2016).", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 106, + 408, + 505, + 475 + ], + "lines": [ + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 159, + 421 + ], + "score": 1.0, + "content": "As shown in", + "type": "text" + }, + { + "bbox": [ + 159, + 409, + 187, + 420 + ], + "score": 0.25, + "content": "\\mathrm { F i g } 1 2", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 408, + 505, + 421 + ], + "score": 1.0, + "content": ", our predictor produces three sets of outputs: (a) one frame of new pixels, (b)", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 419, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 336, + 432 + ], + "score": 1.0, + "content": "“appearance flow” (Zhou et al., 2016) maps that warp the", + "type": "text" + }, + { + "bbox": [ + 336, + 420, + 350, + 431 + ], + "score": 0.9, + "content": "| C |", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 419, + 444, + 432 + ], + "score": 1.0, + "content": "input image(s), and (c)", + "type": "text" + }, + { + "bbox": [ + 445, + 420, + 477, + 431 + ], + "score": 0.92, + "content": "| C | + 1", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 419, + 506, + 432 + ], + "score": 1.0, + "content": "masks", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 430, + 506, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 506, + 443 + ], + "score": 1.0, + "content": "(summing to 1 at each pixel) that combine the warped input images and the new pixels frame to", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 442, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 505, + 453 + ], + "score": 1.0, + "content": "produce the final output. To produce these three outputs, we use three decoders that all have the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 453, + 504, + 464 + ], + "spans": [ + { + "bbox": [ + 106, + 453, + 504, + 464 + ], + "score": 1.0, + "content": "same architecture as above, except that the final output is shaped appropriately—the appearance flow", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 463, + 501, + 476 + ], + "spans": [ + { + "bbox": [ + 106, + 463, + 179, + 476 + ], + "score": 1.0, + "content": "decoder produces", + "type": "text" + }, + { + "bbox": [ + 179, + 463, + 224, + 475 + ], + "score": 0.87, + "content": "\\vert C \\vert \\mathrm { x 6 4 x 6 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 224, + 463, + 401, + 476 + ], + "score": 1.0, + "content": "flowfields, and the masks decoder produces", + "type": "text" + }, + { + "bbox": [ + 401, + 463, + 470, + 475 + ], + "score": 0.89, + "content": "( | C | + 1 ) \\mathrm { x } 6 4 \\mathrm { x } 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 463, + 501, + 476 + ], + "score": 1.0, + "content": "masks.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 106, + 493, + 505, + 560 + ], + "lines": [ + { + "bbox": [ + 105, + 493, + 506, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 506, + 506 + ], + "score": 1.0, + "content": "Discriminator and Recognition Network The VAE recognition network and the discriminator", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 504, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 505, + 518 + ], + "score": 1.0, + "content": "both use similar architectures to the predictor encoder above. Only the input layer and the output layer", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 516, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 516, + 326, + 529 + ], + "score": 1.0, + "content": "are changed as follows: (a) The discriminator accepts", + "type": "text" + }, + { + "bbox": [ + 326, + 516, + 357, + 528 + ], + "score": 0.92, + "content": "| C | + 1", + "type": "inline_equation" + }, + { + "bbox": [ + 358, + 516, + 505, + 529 + ], + "score": 1.0, + "content": "images as input and the recognition", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 527, + 504, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 173, + 540 + ], + "score": 1.0, + "content": "network accepts", + "type": "text" + }, + { + "bbox": [ + 174, + 528, + 212, + 539 + ], + "score": 0.91, + "content": "| C | + | T |", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 527, + 490, + 540 + ], + "score": 1.0, + "content": "images (the full video) as input. (b) The discriminator head produces", + "type": "text" + }, + { + "bbox": [ + 490, + 527, + 504, + 539 + ], + "score": 0.87, + "content": "| T |", + "type": "inline_equation" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 538, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 505, + 551 + ], + "score": 1.0, + "content": "logits (one corresponding to each target time), and the recognition network produces a 32-dimensional", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 550, + 181, + 561 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 181, + 561 + ], + "score": 1.0, + "content": "conditional latent.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 107, + 579, + 505, + 624 + ], + "lines": [ + { + "bbox": [ + 106, + 580, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 106, + 580, + 505, + 591 + ], + "score": 1.0, + "content": "Training. We found it beneficial to initialize the decoder by training it first as an unconditional", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 591, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 591, + 505, + 603 + ], + "score": 1.0, + "content": "frame generator on frames from the training videos. For this pretraining, we use learning rate 0.0001", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 601, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 505, + 614 + ], + "score": 1.0, + "content": "for 10 epochs with batch size 64 and Adam optimizer. Thereafter, for training, we use learning rate", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 613, + 359, + 625 + ], + "spans": [ + { + "bbox": [ + 106, + 613, + 359, + 625 + ], + "score": 1.0, + "content": "0.0001 for 200 epochs with batch size 64 and Adam optimizer.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34.5 + }, + { + "type": "title", + "bbox": [ + 108, + 647, + 228, + 660 + ], + "lines": [ + { + "bbox": [ + 106, + 646, + 230, + 662 + ], + "spans": [ + { + "bbox": [ + 106, + 646, + 230, + 662 + ], + "score": 1.0, + "content": "D DATA GENERATION", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 677, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 109, + 677, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 109, + 677, + 506, + 689 + ], + "score": 1.0, + "content": "To generate the data, we use a cross-entropy method (CEM)-based planner (Kroese et al., 2013;", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "Ebert et al., 2017) in the MuJoCo (Todorov et al., 2012) environment with access to the physics", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "engine, which produces non-deterministic trajectories. The planner plans towards randomly provided", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 709, + 507, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 507, + 723 + ], + "score": 1.0, + "content": "goals, but we use both successful and failed trajectories. Sample videos of episodes are shown at:", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 721, + 331, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 331, + 733 + ], + "score": 1.0, + "content": "https://sites.google.com/view/ta-pred", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40 + } + ], + "page_idx": 12, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 135, + 78, + 477, + 168 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 135, + 78, + 477, + 168 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 135, + 78, + 477, + 168 + ], + "spans": [ + { + "bbox": [ + 135, + 78, + 477, + 168 + ], + "score": 0.968, + "type": "image", + "image_path": "f8856cd9f2f3798eee429753195214b113ada59861c91af370862789af7f7cd3.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 135, + 78, + 477, + 108.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 135, + 108.0, + 477, + 138.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 135, + 138.0, + 477, + 168.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 177, + 505, + 198 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 176, + 506, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 506, + 189 + ], + "score": 1.0, + "content": "Figure 12: The predictor produces an appearance flowfield which is used to produce flow-warped input frames,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 187, + 456, + 198 + ], + "spans": [ + { + "bbox": [ + 106, + 187, + 456, + 198 + ], + "score": 1.0, + "content": "which together with a frame of new pixels are masked and averaged to produce the output frame.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 107, + 215, + 505, + 248 + ], + "lines": [], + "index": 6, + "bbox_fs": [ + 105, + 215, + 506, + 248 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 254, + 505, + 320 + ], + "lines": [ + { + "bbox": [ + 106, + 254, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 106, + 254, + 505, + 267 + ], + "score": 1.0, + "content": "The encoder inside the predictor uses a series of 4x4convolution-batchnorm-LeakyReLU(0.2) blocks", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 265, + 506, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 253, + 277 + ], + "score": 1.0, + "content": "to reduce the 64x64 input image as", + "type": "text" + }, + { + "bbox": [ + 253, + 265, + 483, + 276 + ], + "score": 0.83, + "content": "3 \\mathrm { x 6 4 \\mathrm { x 6 4 } } { } 3 2 \\mathrm { x } 3 2 \\mathrm { x } 3 2 { } 6 4 \\mathrm { x } 1 6 \\mathrm { x } 1 6 { } 1 2 8 \\mathrm { x } 8 \\mathrm { x } 8 { } 2 5 6 \\mathrm { x } 4 \\mathrm { x } 4", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 265, + 506, + 277 + ], + "score": 1.0, + "content": ". For", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 276, + 504, + 288 + ], + "spans": [ + { + "bbox": [ + 106, + 276, + 466, + 288 + ], + "score": 1.0, + "content": "bidirectional prediction, this is repeated for both images and concatenated to produce a", + "type": "text" + }, + { + "bbox": [ + 467, + 276, + 504, + 286 + ], + "score": 0.71, + "content": "5 1 2 \\mathrm { x } 4 \\mathrm { x } 4", + "type": "inline_equation" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 287, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 106, + 287, + 505, + 298 + ], + "score": 1.0, + "content": "feature map. Finally, a small convolution-ReLU-convolution head reduces this to a 128-dimensional", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 298, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 106, + 298, + 506, + 310 + ], + "score": 1.0, + "content": "vector. Except for this last head subnetwork, this architecture is identical to the DCGAN discrimina-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 309, + 210, + 320 + ], + "spans": [ + { + "bbox": [ + 106, + 309, + 210, + 320 + ], + "score": 1.0, + "content": "tor (Radford et al., 2015).", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 254, + 506, + 320 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 325, + 505, + 403 + ], + "lines": [ + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "The decoder inside the predictor uses a DCGAN-based architecture (Radford et al., 2015).", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 336, + 507, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 391, + 350 + ], + "score": 1.0, + "content": "The input vector is reshaped by a transposed convolution into 256", + "type": "text" + }, + { + "bbox": [ + 392, + 337, + 412, + 347 + ], + "score": 0.61, + "content": "4 \\times 4", + "type": "inline_equation" + }, + { + "bbox": [ + 412, + 336, + 507, + 350 + ], + "score": 1.0, + "content": "maps. This is subse-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 347, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 506, + 361 + ], + "score": 1.0, + "content": "quently processed a series of bilinear upsampling-5x5convolution-batchnorm-ReLU blocks as", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 358, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 106, + 358, + 285, + 369 + ], + "score": 0.91, + "content": "2 5 6 \\times 4 \\times 4 - 1 2 8 \\times 8 \\times 8 6 4 \\mathrm { x } 3 2 \\mathrm { x } 3 2 3 \\mathrm { x } 6 4 \\mathrm { x } \\bar { 6 } 4", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 358, + 505, + 371 + ], + "score": 1.0, + "content": ". For the last block, a Tanh activation is used in place", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 370, + 505, + 382 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 505, + 382 + ], + "score": 1.0, + "content": "of ReLU to keep outputs in [-1,1]. Compared to (Radford et al., 2015), the main difference is that", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 381, + 506, + 393 + ], + "spans": [ + { + "bbox": [ + 106, + 381, + 506, + 393 + ], + "score": 1.0, + "content": "transposed convolutions are replaced by upsampling-5x5 convolution blocks, which aids in faster", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 392, + 333, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 333, + 404 + ], + "score": 1.0, + "content": "learning with fewer image artifacts (Odena et al., 2016).", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 325, + 507, + 404 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 408, + 505, + 475 + ], + "lines": [ + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 159, + 421 + ], + "score": 1.0, + "content": "As shown in", + "type": "text" + }, + { + "bbox": [ + 159, + 409, + 187, + 420 + ], + "score": 0.25, + "content": "\\mathrm { F i g } 1 2", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 408, + 505, + 421 + ], + "score": 1.0, + "content": ", our predictor produces three sets of outputs: (a) one frame of new pixels, (b)", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 419, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 336, + 432 + ], + "score": 1.0, + "content": "“appearance flow” (Zhou et al., 2016) maps that warp the", + "type": "text" + }, + { + "bbox": [ + 336, + 420, + 350, + 431 + ], + "score": 0.9, + "content": "| C |", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 419, + 444, + 432 + ], + "score": 1.0, + "content": "input image(s), and (c)", + "type": "text" + }, + { + "bbox": [ + 445, + 420, + 477, + 431 + ], + "score": 0.92, + "content": "| C | + 1", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 419, + 506, + 432 + ], + "score": 1.0, + "content": "masks", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 430, + 506, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 506, + 443 + ], + "score": 1.0, + "content": "(summing to 1 at each pixel) that combine the warped input images and the new pixels frame to", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 442, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 505, + 453 + ], + "score": 1.0, + "content": "produce the final output. To produce these three outputs, we use three decoders that all have the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 453, + 504, + 464 + ], + "spans": [ + { + "bbox": [ + 106, + 453, + 504, + 464 + ], + "score": 1.0, + "content": "same architecture as above, except that the final output is shaped appropriately—the appearance flow", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 463, + 501, + 476 + ], + "spans": [ + { + "bbox": [ + 106, + 463, + 179, + 476 + ], + "score": 1.0, + "content": "decoder produces", + "type": "text" + }, + { + "bbox": [ + 179, + 463, + 224, + 475 + ], + "score": 0.87, + "content": "\\vert C \\vert \\mathrm { x 6 4 x 6 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 224, + 463, + 401, + 476 + ], + "score": 1.0, + "content": "flowfields, and the masks decoder produces", + "type": "text" + }, + { + "bbox": [ + 401, + 463, + 470, + 475 + ], + "score": 0.89, + "content": "( | C | + 1 ) \\mathrm { x } 6 4 \\mathrm { x } 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 463, + 501, + 476 + ], + "score": 1.0, + "content": "masks.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 408, + 506, + 476 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 493, + 505, + 560 + ], + "lines": [ + { + "bbox": [ + 105, + 493, + 506, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 506, + 506 + ], + "score": 1.0, + "content": "Discriminator and Recognition Network The VAE recognition network and the discriminator", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 504, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 505, + 518 + ], + "score": 1.0, + "content": "both use similar architectures to the predictor encoder above. Only the input layer and the output layer", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 516, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 516, + 326, + 529 + ], + "score": 1.0, + "content": "are changed as follows: (a) The discriminator accepts", + "type": "text" + }, + { + "bbox": [ + 326, + 516, + 357, + 528 + ], + "score": 0.92, + "content": "| C | + 1", + "type": "inline_equation" + }, + { + "bbox": [ + 358, + 516, + 505, + 529 + ], + "score": 1.0, + "content": "images as input and the recognition", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 527, + 504, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 173, + 540 + ], + "score": 1.0, + "content": "network accepts", + "type": "text" + }, + { + "bbox": [ + 174, + 528, + 212, + 539 + ], + "score": 0.91, + "content": "| C | + | T |", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 527, + 490, + 540 + ], + "score": 1.0, + "content": "images (the full video) as input. (b) The discriminator head produces", + "type": "text" + }, + { + "bbox": [ + 490, + 527, + 504, + 539 + ], + "score": 0.87, + "content": "| T |", + "type": "inline_equation" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 538, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 505, + 551 + ], + "score": 1.0, + "content": "logits (one corresponding to each target time), and the recognition network produces a 32-dimensional", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 550, + 181, + 561 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 181, + 561 + ], + "score": 1.0, + "content": "conditional latent.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 29.5, + "bbox_fs": [ + 105, + 493, + 506, + 561 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 579, + 505, + 624 + ], + "lines": [ + { + "bbox": [ + 106, + 580, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 106, + 580, + 505, + 591 + ], + "score": 1.0, + "content": "Training. We found it beneficial to initialize the decoder by training it first as an unconditional", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 591, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 591, + 505, + 603 + ], + "score": 1.0, + "content": "frame generator on frames from the training videos. For this pretraining, we use learning rate 0.0001", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 601, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 505, + 614 + ], + "score": 1.0, + "content": "for 10 epochs with batch size 64 and Adam optimizer. Thereafter, for training, we use learning rate", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 613, + 359, + 625 + ], + "spans": [ + { + "bbox": [ + 106, + 613, + 359, + 625 + ], + "score": 1.0, + "content": "0.0001 for 200 epochs with batch size 64 and Adam optimizer.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 580, + 505, + 625 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 647, + 228, + 660 + ], + "lines": [ + { + "bbox": [ + 106, + 646, + 230, + 662 + ], + "spans": [ + { + "bbox": [ + 106, + 646, + 230, + 662 + ], + "score": 1.0, + "content": "D DATA GENERATION", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 677, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 109, + 677, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 109, + 677, + 506, + 689 + ], + "score": 1.0, + "content": "To generate the data, we use a cross-entropy method (CEM)-based planner (Kroese et al., 2013;", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "Ebert et al., 2017) in the MuJoCo (Todorov et al., 2012) environment with access to the physics", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "engine, which produces non-deterministic trajectories. The planner plans towards randomly provided", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 709, + 507, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 507, + 723 + ], + "score": 1.0, + "content": "goals, but we use both successful and failed trajectories. Sample videos of episodes are shown at:", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 721, + 331, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 331, + 733 + ], + "score": 1.0, + "content": "https://sites.google.com/view/ta-pred", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40, + "bbox_fs": [ + 105, + 677, + 507, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 105, + 81, + 483, + 94 + ], + "lines": [ + { + "bbox": [ + 104, + 79, + 485, + 96 + ], + "spans": [ + { + "bbox": [ + 104, + 79, + 485, + 96 + ], + "score": 1.0, + "content": "E GENERALIZED MINIMUM WEIGHTS FOR INTERMEDIATE PREDICTION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 107, + 505, + 163 + ], + "lines": [ + { + "bbox": [ + 105, + 105, + 506, + 121 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 322, + 121 + ], + "score": 1.0, + "content": "In Sec 4, we briefly mentioned that the time preference", + "type": "text" + }, + { + "bbox": [ + 323, + 107, + 343, + 119 + ], + "score": 0.91, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 105, + 506, + 121 + ], + "score": 1.0, + "content": "for the generalized minimum loss during", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 117, + 507, + 131 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 507, + 131 + ], + "score": 1.0, + "content": "intermediate frame prediction was set to 2/3 at the ends to 1 at the middle frame. In our experiments,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 129, + 505, + 141 + ], + "spans": [ + { + "bbox": [ + 105, + 129, + 286, + 141 + ], + "score": 1.0, + "content": "we set these weights heuristically as follows:", + "type": "text" + }, + { + "bbox": [ + 287, + 129, + 306, + 141 + ], + "score": 0.92, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 129, + 383, + 141 + ], + "score": 1.0, + "content": "rises linearly from", + "type": "text" + }, + { + "bbox": [ + 383, + 130, + 421, + 140 + ], + "score": 0.89, + "content": "\\kappa = 0 . 6 6", + "type": "inline_equation" + }, + { + "bbox": [ + 421, + 129, + 431, + 141 + ], + "score": 1.0, + "content": "at", + "type": "text" + }, + { + "bbox": [ + 432, + 130, + 455, + 140 + ], + "score": 0.9, + "content": "t = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 455, + 129, + 505, + 141 + ], + "score": 1.0, + "content": "to 1.0 at the", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 107, + 139, + 505, + 154 + ], + "spans": [ + { + "bbox": [ + 107, + 141, + 130, + 151 + ], + "score": 0.88, + "content": "t = 5", + "type": "inline_equation" + }, + { + "bbox": [ + 130, + 139, + 212, + 154 + ], + "score": 1.0, + "content": ", then stay at 1.0 for", + "type": "text" + }, + { + "bbox": [ + 212, + 141, + 243, + 151 + ], + "score": 0.86, + "content": "T - 1 0", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 139, + 374, + 154 + ], + "score": 1.0, + "content": "frames. Then, starting from the", + "type": "text" + }, + { + "bbox": [ + 374, + 141, + 406, + 152 + ], + "score": 0.92, + "content": "( T - 5 )", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 139, + 505, + 154 + ], + "score": 1.0, + "content": "-th frame, it would drop", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 151, + 506, + 164 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 149, + 164 + ], + "score": 1.0, + "content": "linearly to", + "type": "text" + }, + { + "bbox": [ + 149, + 153, + 156, + 161 + ], + "score": 0.76, + "content": "\\kappa", + "type": "inline_equation" + }, + { + "bbox": [ + 156, + 151, + 210, + 164 + ], + "score": 1.0, + "content": "once more at", + "type": "text" + }, + { + "bbox": [ + 210, + 152, + 235, + 161 + ], + "score": 0.9, + "content": "t = T", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 151, + 396, + 164 + ], + "score": 1.0, + "content": ". The only hyperparameter we tuned was", + "type": "text" + }, + { + "bbox": [ + 397, + 153, + 403, + 161 + ], + "score": 0.76, + "content": "\\kappa", + "type": "inline_equation" + }, + { + "bbox": [ + 404, + 151, + 454, + 164 + ], + "score": 1.0, + "content": "(search over", + "type": "text" + }, + { + "bbox": [ + 455, + 151, + 468, + 162 + ], + "score": 0.31, + "content": "2 / 3", + "type": "inline_equation" + }, + { + "bbox": [ + 469, + 151, + 486, + 164 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 487, + 152, + 500, + 162 + ], + "score": 0.52, + "content": "1 / 3", + "type": "inline_equation" + }, + { + "bbox": [ + 500, + 151, + 506, + 164 + ], + "score": 1.0, + "content": ").", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3 + }, + { + "type": "title", + "bbox": [ + 107, + 180, + 366, + 194 + ], + "lines": [ + { + "bbox": [ + 104, + 180, + 367, + 196 + ], + "spans": [ + { + "bbox": [ + 104, + 180, + 367, + 196 + ], + "score": 1.0, + "content": "F BOTTLENECK DISCOVERY FREQUENCY SCORE", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 108, + 207, + 504, + 229 + ], + "lines": [ + { + "bbox": [ + 106, + 207, + 505, + 221 + ], + "spans": [ + { + "bbox": [ + 106, + 207, + 505, + 221 + ], + "score": 1.0, + "content": "In Sec 4, we mentioned a bottleneck discovery frequency measure in the paragraph titled “Bottleneck", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 218, + 352, + 230 + ], + "spans": [ + { + "bbox": [ + 106, + 218, + 352, + 230 + ], + "score": 1.0, + "content": "discovery frequency metric.” We now provide further details.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 107, + 235, + 505, + 301 + ], + "lines": [ + { + "bbox": [ + 105, + 235, + 506, + 248 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 506, + 248 + ], + "score": 1.0, + "content": "Our proposed metric for two-object pushing quantifies how reliably the network is able to generate a", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 246, + 506, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 506, + 259 + ], + "score": 1.0, + "content": "bottleneck state with one object being moved and the other being at its original position. The reason", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 257, + 505, + 270 + ], + "spans": [ + { + "bbox": [ + 105, + 257, + 505, + 270 + ], + "score": 1.0, + "content": "that this state is of interest is that in two-object pushing, this may be reasonably assumed to be the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 267, + 505, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 505, + 281 + ], + "score": 1.0, + "content": "natural bottleneck, so we call this metric the bottleneck frequency. Even without this assumption", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 279, + 506, + 292 + ], + "spans": [ + { + "bbox": [ + 105, + 279, + 506, + 292 + ], + "score": 1.0, + "content": "though, the metric quantifies the ability of our approach to generate predictions attached to this", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 290, + 315, + 303 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 315, + 303 + ], + "score": 1.0, + "content": "consistent semantically coherent bidirectional state.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 107, + 307, + 505, + 438 + ], + "lines": [ + { + "bbox": [ + 105, + 307, + 506, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 506, + 320 + ], + "score": 1.0, + "content": "To measure bottleneck frequency, we use a technique similar to the approach proposed in (Ebert", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 104, + 317, + 507, + 330 + ], + "spans": [ + { + "bbox": [ + 104, + 317, + 507, + 330 + ], + "score": 1.0, + "content": "et al., 2017) for planning with a visual predictor. First, we train versions of “genmin” and “fix”", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 328, + 505, + 342 + ], + "spans": [ + { + "bbox": [ + 105, + 328, + 505, + 342 + ], + "score": 1.0, + "content": "that synthesize predictions purely by appearance-flow-warping and masking inputs (as shown in the", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 338, + 506, + 354 + ], + "spans": [ + { + "bbox": [ + 104, + 338, + 506, + 354 + ], + "score": 1.0, + "content": "scheme of Fig 12, but without pixel generation). Next, recall that we have access to the starting", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 351, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 505, + 363 + ], + "score": 1.0, + "content": "and goal positions of objects since our dataset is synthetically generated. Thus, we can exploit this", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 362, + 505, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 505, + 374 + ], + "score": 1.0, + "content": "and track where the pixels at ground truth object locations in start and goal images end up in the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 373, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 373, + 505, + 385 + ], + "score": 1.0, + "content": "prediction, i.e., where did each object move? This works as follows: we take the appearance flow", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 383, + 505, + 396 + ], + "spans": [ + { + "bbox": [ + 106, + 383, + 505, + 396 + ], + "score": 1.0, + "content": "transformations and masks generated by the model internally (for application to input images to", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 395, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 505, + 407 + ], + "score": 1.0, + "content": "generate prediction) and apply them instead to one-hot object location maps—these maps have value", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 406, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 505, + 418 + ], + "score": 1.0, + "content": "one at the ground truth origin of the the objects and zero elsewhere. The output of this operation", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 416, + 505, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 505, + 430 + ], + "score": 1.0, + "content": "is a probability map for each object indicating where it is located in the predictor’s bidirectional", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 428, + 179, + 440 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 179, + 440 + ], + "score": 1.0, + "content": "prediction output.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 107, + 444, + 505, + 510 + ], + "lines": [ + { + "bbox": [ + 106, + 444, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 444, + 505, + 457 + ], + "score": 1.0, + "content": "To compute the score, we then calculate the expected distance in pixels between the predicted", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 455, + 506, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 506, + 468 + ], + "score": 1.0, + "content": "positions of each object and the bottleneck state. There are actually two possible candidates for this", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 465, + 506, + 479 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 506, + 479 + ], + "score": 1.0, + "content": "bottleneck state: object 1 is moved first, or object 2 is moved first. We compute the expected distances", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 478, + 505, + 489 + ], + "spans": [ + { + "bbox": [ + 106, + 478, + 505, + 489 + ], + "score": 1.0, + "content": "to both these bottleneck candidates and take the lower distance to be the score. This score does not", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 489, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 505, + 500 + ], + "score": 1.0, + "content": "evaluate whether the semantically correct bottleneck was predicted (in cases where one object must", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 500, + 401, + 511 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 401, + 511 + ], + "score": 1.0, + "content": "always be moved first to avoid collision, such as Fig 9 (left) example #1).", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 107, + 516, + 505, + 593 + ], + "lines": [ + { + "bbox": [ + 105, + 515, + 506, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 506, + 528 + ], + "score": 1.0, + "content": "The lower this distance score, the higher the likelihood that the predicted output is actually a bottleneck", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 526, + 506, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 506, + 540 + ], + "score": 1.0, + "content": "(“bottleneck frequency”). Fig 10 shows what happens when the threshold over the score is varied, for", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 537, + 507, + 550 + ], + "spans": [ + { + "bbox": [ + 104, + 537, + 507, + 550 + ], + "score": 1.0, + "content": "our approach and the fixed-time baseline. Higher bottleneck frequency at lower threshold is desirable.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 549, + 505, + 562 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 326, + 562 + ], + "score": 1.0, + "content": "As the figure shows, at a low threshold distance score", + "type": "text" + }, + { + "bbox": [ + 326, + 550, + 343, + 560 + ], + "score": 0.79, + "content": "\\approx 2", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 549, + 484, + 562 + ], + "score": 1.0, + "content": "pixels), our approach gets to about", + "type": "text" + }, + { + "bbox": [ + 485, + 549, + 505, + 560 + ], + "score": 0.85, + "content": "58 \\%", + "type": "inline_equation" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 560, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 357, + 572 + ], + "score": 1.0, + "content": "bottleneck frequency while the fixed-time predictor gets about", + "type": "text" + }, + { + "bbox": [ + 357, + 560, + 372, + 570 + ], + "score": 0.87, + "content": "0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 560, + 505, + 572 + ], + "score": 1.0, + "content": "frequency at this threshold. This", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 570, + 505, + 585 + ], + "spans": [ + { + "bbox": [ + 104, + 570, + 505, + 585 + ], + "score": 1.0, + "content": "verifies that our approach produces predictions attached to semantically coherent low-uncertainty", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 581, + 181, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 181, + 594 + ], + "score": 1.0, + "content": "bottleneck events.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36 + }, + { + "type": "title", + "bbox": [ + 107, + 611, + 380, + 624 + ], + "lines": [ + { + "bbox": [ + 105, + 610, + 381, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 381, + 626 + ], + "score": 1.0, + "content": "G HIERARCHICAL PLANNING EVALUTION METHOD", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 105, + 638, + 504, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 637, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 651 + ], + "score": 1.0, + "content": "In Sec 4, we described a hierarchical planning approach using our predictions in the paragraph titled", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 648, + 429, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 429, + 661 + ], + "score": 1.0, + "content": "“Hierarchical planning evaluation.” We describe this method in more detail here.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 664, + 506, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 506, + 679 + ], + "score": 1.0, + "content": "We test the usefulness of the generated predictions as subgoals for planning multi-object pushing.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "Given a start and goal image, we produce an bidirectional prediction using our time-agnostic predictor", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "score": 1.0, + "content": "and feed it to a low-level planner that plans towards this prediction as its subgoal. For the low-level", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "planner we use the visual model-predictive control algorithm (“Visual MPC”) (Ebert et al., 2017)", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "which internally uses a fixed-time forward prediction model and sampling-based planning to solve", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 720, + 472, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 472, + 733 + ], + "score": 1.0, + "content": "short-term and medium duration tasks. A more detailed description of this process follows.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 45.5 + } + ], + "page_idx": 13, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 752, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 105, + 81, + 483, + 94 + ], + "lines": [ + { + "bbox": [ + 104, + 79, + 485, + 96 + ], + "spans": [ + { + "bbox": [ + 104, + 79, + 485, + 96 + ], + "score": 1.0, + "content": "E GENERALIZED MINIMUM WEIGHTS FOR INTERMEDIATE PREDICTION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 107, + 505, + 163 + ], + "lines": [ + { + "bbox": [ + 105, + 105, + 506, + 121 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 322, + 121 + ], + "score": 1.0, + "content": "In Sec 4, we briefly mentioned that the time preference", + "type": "text" + }, + { + "bbox": [ + 323, + 107, + 343, + 119 + ], + "score": 0.91, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 105, + 506, + 121 + ], + "score": 1.0, + "content": "for the generalized minimum loss during", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 117, + 507, + 131 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 507, + 131 + ], + "score": 1.0, + "content": "intermediate frame prediction was set to 2/3 at the ends to 1 at the middle frame. In our experiments,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 129, + 505, + 141 + ], + "spans": [ + { + "bbox": [ + 105, + 129, + 286, + 141 + ], + "score": 1.0, + "content": "we set these weights heuristically as follows:", + "type": "text" + }, + { + "bbox": [ + 287, + 129, + 306, + 141 + ], + "score": 0.92, + "content": "w ( t )", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 129, + 383, + 141 + ], + "score": 1.0, + "content": "rises linearly from", + "type": "text" + }, + { + "bbox": [ + 383, + 130, + 421, + 140 + ], + "score": 0.89, + "content": "\\kappa = 0 . 6 6", + "type": "inline_equation" + }, + { + "bbox": [ + 421, + 129, + 431, + 141 + ], + "score": 1.0, + "content": "at", + "type": "text" + }, + { + "bbox": [ + 432, + 130, + 455, + 140 + ], + "score": 0.9, + "content": "t = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 455, + 129, + 505, + 141 + ], + "score": 1.0, + "content": "to 1.0 at the", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 107, + 139, + 505, + 154 + ], + "spans": [ + { + "bbox": [ + 107, + 141, + 130, + 151 + ], + "score": 0.88, + "content": "t = 5", + "type": "inline_equation" + }, + { + "bbox": [ + 130, + 139, + 212, + 154 + ], + "score": 1.0, + "content": ", then stay at 1.0 for", + "type": "text" + }, + { + "bbox": [ + 212, + 141, + 243, + 151 + ], + "score": 0.86, + "content": "T - 1 0", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 139, + 374, + 154 + ], + "score": 1.0, + "content": "frames. Then, starting from the", + "type": "text" + }, + { + "bbox": [ + 374, + 141, + 406, + 152 + ], + "score": 0.92, + "content": "( T - 5 )", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 139, + 505, + 154 + ], + "score": 1.0, + "content": "-th frame, it would drop", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 151, + 506, + 164 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 149, + 164 + ], + "score": 1.0, + "content": "linearly to", + "type": "text" + }, + { + "bbox": [ + 149, + 153, + 156, + 161 + ], + "score": 0.76, + "content": "\\kappa", + "type": "inline_equation" + }, + { + "bbox": [ + 156, + 151, + 210, + 164 + ], + "score": 1.0, + "content": "once more at", + "type": "text" + }, + { + "bbox": [ + 210, + 152, + 235, + 161 + ], + "score": 0.9, + "content": "t = T", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 151, + 396, + 164 + ], + "score": 1.0, + "content": ". The only hyperparameter we tuned was", + "type": "text" + }, + { + "bbox": [ + 397, + 153, + 403, + 161 + ], + "score": 0.76, + "content": "\\kappa", + "type": "inline_equation" + }, + { + "bbox": [ + 404, + 151, + 454, + 164 + ], + "score": 1.0, + "content": "(search over", + "type": "text" + }, + { + "bbox": [ + 455, + 151, + 468, + 162 + ], + "score": 0.31, + "content": "2 / 3", + "type": "inline_equation" + }, + { + "bbox": [ + 469, + 151, + 486, + 164 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 487, + 152, + 500, + 162 + ], + "score": 0.52, + "content": "1 / 3", + "type": "inline_equation" + }, + { + "bbox": [ + 500, + 151, + 506, + 164 + ], + "score": 1.0, + "content": ").", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3, + "bbox_fs": [ + 105, + 105, + 507, + 164 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 180, + 366, + 194 + ], + "lines": [ + { + "bbox": [ + 104, + 180, + 367, + 196 + ], + "spans": [ + { + "bbox": [ + 104, + 180, + 367, + 196 + ], + "score": 1.0, + "content": "F BOTTLENECK DISCOVERY FREQUENCY SCORE", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 108, + 207, + 504, + 229 + ], + "lines": [ + { + "bbox": [ + 106, + 207, + 505, + 221 + ], + "spans": [ + { + "bbox": [ + 106, + 207, + 505, + 221 + ], + "score": 1.0, + "content": "In Sec 4, we mentioned a bottleneck discovery frequency measure in the paragraph titled “Bottleneck", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 218, + 352, + 230 + ], + "spans": [ + { + "bbox": [ + 106, + 218, + 352, + 230 + ], + "score": 1.0, + "content": "discovery frequency metric.” We now provide further details.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5, + "bbox_fs": [ + 106, + 207, + 505, + 230 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 235, + 505, + 301 + ], + "lines": [ + { + "bbox": [ + 105, + 235, + 506, + 248 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 506, + 248 + ], + "score": 1.0, + "content": "Our proposed metric for two-object pushing quantifies how reliably the network is able to generate a", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 246, + 506, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 506, + 259 + ], + "score": 1.0, + "content": "bottleneck state with one object being moved and the other being at its original position. The reason", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 257, + 505, + 270 + ], + "spans": [ + { + "bbox": [ + 105, + 257, + 505, + 270 + ], + "score": 1.0, + "content": "that this state is of interest is that in two-object pushing, this may be reasonably assumed to be the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 267, + 505, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 505, + 281 + ], + "score": 1.0, + "content": "natural bottleneck, so we call this metric the bottleneck frequency. Even without this assumption", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 279, + 506, + 292 + ], + "spans": [ + { + "bbox": [ + 105, + 279, + 506, + 292 + ], + "score": 1.0, + "content": "though, the metric quantifies the ability of our approach to generate predictions attached to this", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 290, + 315, + 303 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 315, + 303 + ], + "score": 1.0, + "content": "consistent semantically coherent bidirectional state.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 235, + 506, + 303 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 307, + 505, + 438 + ], + "lines": [ + { + "bbox": [ + 105, + 307, + 506, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 506, + 320 + ], + "score": 1.0, + "content": "To measure bottleneck frequency, we use a technique similar to the approach proposed in (Ebert", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 104, + 317, + 507, + 330 + ], + "spans": [ + { + "bbox": [ + 104, + 317, + 507, + 330 + ], + "score": 1.0, + "content": "et al., 2017) for planning with a visual predictor. First, we train versions of “genmin” and “fix”", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 328, + 505, + 342 + ], + "spans": [ + { + "bbox": [ + 105, + 328, + 505, + 342 + ], + "score": 1.0, + "content": "that synthesize predictions purely by appearance-flow-warping and masking inputs (as shown in the", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 338, + 506, + 354 + ], + "spans": [ + { + "bbox": [ + 104, + 338, + 506, + 354 + ], + "score": 1.0, + "content": "scheme of Fig 12, but without pixel generation). Next, recall that we have access to the starting", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 351, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 505, + 363 + ], + "score": 1.0, + "content": "and goal positions of objects since our dataset is synthetically generated. Thus, we can exploit this", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 362, + 505, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 505, + 374 + ], + "score": 1.0, + "content": "and track where the pixels at ground truth object locations in start and goal images end up in the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 373, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 373, + 505, + 385 + ], + "score": 1.0, + "content": "prediction, i.e., where did each object move? This works as follows: we take the appearance flow", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 383, + 505, + 396 + ], + "spans": [ + { + "bbox": [ + 106, + 383, + 505, + 396 + ], + "score": 1.0, + "content": "transformations and masks generated by the model internally (for application to input images to", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 395, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 505, + 407 + ], + "score": 1.0, + "content": "generate prediction) and apply them instead to one-hot object location maps—these maps have value", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 406, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 505, + 418 + ], + "score": 1.0, + "content": "one at the ground truth origin of the the objects and zero elsewhere. The output of this operation", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 416, + 505, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 505, + 430 + ], + "score": 1.0, + "content": "is a probability map for each object indicating where it is located in the predictor’s bidirectional", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 428, + 179, + 440 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 179, + 440 + ], + "score": 1.0, + "content": "prediction output.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 20.5, + "bbox_fs": [ + 104, + 307, + 507, + 440 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 444, + 505, + 510 + ], + "lines": [ + { + "bbox": [ + 106, + 444, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 444, + 505, + 457 + ], + "score": 1.0, + "content": "To compute the score, we then calculate the expected distance in pixels between the predicted", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 455, + 506, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 506, + 468 + ], + "score": 1.0, + "content": "positions of each object and the bottleneck state. There are actually two possible candidates for this", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 465, + 506, + 479 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 506, + 479 + ], + "score": 1.0, + "content": "bottleneck state: object 1 is moved first, or object 2 is moved first. We compute the expected distances", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 478, + 505, + 489 + ], + "spans": [ + { + "bbox": [ + 106, + 478, + 505, + 489 + ], + "score": 1.0, + "content": "to both these bottleneck candidates and take the lower distance to be the score. This score does not", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 489, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 505, + 500 + ], + "score": 1.0, + "content": "evaluate whether the semantically correct bottleneck was predicted (in cases where one object must", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 500, + 401, + 511 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 401, + 511 + ], + "score": 1.0, + "content": "always be moved first to avoid collision, such as Fig 9 (left) example #1).", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 29.5, + "bbox_fs": [ + 105, + 444, + 506, + 511 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 516, + 505, + 593 + ], + "lines": [ + { + "bbox": [ + 105, + 515, + 506, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 506, + 528 + ], + "score": 1.0, + "content": "The lower this distance score, the higher the likelihood that the predicted output is actually a bottleneck", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 526, + 506, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 506, + 540 + ], + "score": 1.0, + "content": "(“bottleneck frequency”). Fig 10 shows what happens when the threshold over the score is varied, for", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 537, + 507, + 550 + ], + "spans": [ + { + "bbox": [ + 104, + 537, + 507, + 550 + ], + "score": 1.0, + "content": "our approach and the fixed-time baseline. Higher bottleneck frequency at lower threshold is desirable.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 549, + 505, + 562 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 326, + 562 + ], + "score": 1.0, + "content": "As the figure shows, at a low threshold distance score", + "type": "text" + }, + { + "bbox": [ + 326, + 550, + 343, + 560 + ], + "score": 0.79, + "content": "\\approx 2", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 549, + 484, + 562 + ], + "score": 1.0, + "content": "pixels), our approach gets to about", + "type": "text" + }, + { + "bbox": [ + 485, + 549, + 505, + 560 + ], + "score": 0.85, + "content": "58 \\%", + "type": "inline_equation" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 560, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 357, + 572 + ], + "score": 1.0, + "content": "bottleneck frequency while the fixed-time predictor gets about", + "type": "text" + }, + { + "bbox": [ + 357, + 560, + 372, + 570 + ], + "score": 0.87, + "content": "0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 560, + 505, + 572 + ], + "score": 1.0, + "content": "frequency at this threshold. This", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 570, + 505, + 585 + ], + "spans": [ + { + "bbox": [ + 104, + 570, + 505, + 585 + ], + "score": 1.0, + "content": "verifies that our approach produces predictions attached to semantically coherent low-uncertainty", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 581, + 181, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 181, + 594 + ], + "score": 1.0, + "content": "bottleneck events.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36, + "bbox_fs": [ + 104, + 515, + 507, + 594 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 611, + 380, + 624 + ], + "lines": [ + { + "bbox": [ + 105, + 610, + 381, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 381, + 626 + ], + "score": 1.0, + "content": "G HIERARCHICAL PLANNING EVALUTION METHOD", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 105, + 638, + 504, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 637, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 651 + ], + "score": 1.0, + "content": "In Sec 4, we described a hierarchical planning approach using our predictions in the paragraph titled", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 648, + 429, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 429, + 661 + ], + "score": 1.0, + "content": "“Hierarchical planning evaluation.” We describe this method in more detail here.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5, + "bbox_fs": [ + 105, + 637, + 505, + 661 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 664, + 506, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 506, + 679 + ], + "score": 1.0, + "content": "We test the usefulness of the generated predictions as subgoals for planning multi-object pushing.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "Given a start and goal image, we produce an bidirectional prediction using our time-agnostic predictor", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "score": 1.0, + "content": "and feed it to a low-level planner that plans towards this prediction as its subgoal. For the low-level", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "planner we use the visual model-predictive control algorithm (“Visual MPC”) (Ebert et al., 2017)", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "which internally uses a fixed-time forward prediction model and sampling-based planning to solve", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 720, + 472, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 472, + 733 + ], + "score": 1.0, + "content": "short-term and medium duration tasks. A more detailed description of this process follows.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 45.5, + "bbox_fs": [ + 105, + 664, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 170 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "score": 1.0, + "content": "Visual MPC requires start and goal locations of objects to plan. When used in conjunction with our", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 105 + ], + "score": 1.0, + "content": "method, we first compute the locations of objects at the bidirectional predictions and feed this in", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 505, + 117 + ], + "score": 1.0, + "content": "place of the final goal object locations, so that Visual MPC may plan to first reach the bidirectional", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 506, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 506, + 128 + ], + "score": 1.0, + "content": "prediction as a subgoal/stepping stone towards the final goal. Once the subgoal is reached, Visual", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 506, + 140 + ], + "score": 1.0, + "content": "MPC is fed the final goal. To compute subgoal object locations, we use the same technique as in", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 136, + 505, + 151 + ], + "spans": [ + { + "bbox": [ + 105, + 136, + 505, + 151 + ], + "score": 1.0, + "content": "Appendix F above—one-hot maps of object locations are transformed by the appearance flow maps", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 149, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 444, + 162 + ], + "score": 1.0, + "content": "and masks computed internally by our predictor. This produces a probability map", + "type": "text" + }, + { + "bbox": [ + 444, + 150, + 456, + 161 + ], + "score": 0.85, + "content": "p _ { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 149, + 505, + 162 + ], + "score": 1.0, + "content": "over object", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 344, + 171 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 344, + 171 + ], + "score": 1.0, + "content": "locations at the prediction, which is passed to Visual MPC.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 176, + 505, + 264 + ], + "lines": [ + { + "bbox": [ + 106, + 176, + 505, + 188 + ], + "spans": [ + { + "bbox": [ + 106, + 176, + 505, + 188 + ], + "score": 1.0, + "content": "Internally, the Visual MPC planner makes fixed-time forward predictions for the object locations", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 504, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 249, + 200 + ], + "score": 1.0, + "content": "starting from the initial distribution", + "type": "text" + }, + { + "bbox": [ + 250, + 189, + 260, + 199 + ], + "score": 0.86, + "content": "p _ { s }", + "type": "inline_equation" + }, + { + "bbox": [ + 261, + 187, + 473, + 200 + ], + "score": 1.0, + "content": "given a randomly sampled action sequence of length", + "type": "text" + }, + { + "bbox": [ + 474, + 187, + 504, + 198 + ], + "score": 0.89, + "content": "h = 1 5", + "type": "inline_equation" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 505, + 210 + ], + "score": 1.0, + "content": "(the “planning horizon”). Out of all the action sequences, it selects the sequence that brings the", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 209, + 506, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 194, + 222 + ], + "score": 1.0, + "content": "distribution closest to", + "type": "text" + }, + { + "bbox": [ + 195, + 211, + 206, + 221 + ], + "score": 0.86, + "content": "p _ { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 206, + 209, + 235, + 222 + ], + "score": 1.0, + "content": "within", + "type": "text" + }, + { + "bbox": [ + 235, + 209, + 266, + 219 + ], + "score": 0.9, + "content": "h = 1 5", + "type": "inline_equation" + }, + { + "bbox": [ + 266, + 209, + 292, + 222 + ], + "score": 1.0, + "content": "steps", + "type": "text" + }, + { + "bbox": [ + 293, + 210, + 299, + 219 + ], + "score": 0.72, + "content": "h", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 209, + 506, + 222 + ], + "score": 1.0, + "content": "is the “planning horizon”). In practice, we use 200", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 220, + 505, + 232 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 505, + 232 + ], + "score": 1.0, + "content": "random action sequences and perform three iterations of CEM search (Kroese et al., 2013) to find the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 232, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 106, + 232, + 505, + 243 + ], + "score": 1.0, + "content": "the best sequence. Once an action sequence is selected, the first action in the sequence is executed,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 242, + 505, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 505, + 254 + ], + "score": 1.0, + "content": "and the initial object distribution is updated. New candidate action sequences are now generated", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 253, + 384, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 253, + 384, + 266 + ], + "score": 1.0, + "content": "starting from this updated object distribution and the process repeats.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 107, + 270, + 505, + 336 + ], + "lines": [ + { + "bbox": [ + 106, + 269, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 106, + 269, + 268, + 282 + ], + "score": 1.0, + "content": "In our experiments, we use a time budget", + "type": "text" + }, + { + "bbox": [ + 268, + 270, + 278, + 280 + ], + "score": 0.81, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 269, + 505, + 282 + ], + "score": 1.0, + "content": "of 40 steps for 2-object pushing, and 75 steps for 3-object", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 281, + 506, + 293 + ], + "spans": [ + { + "bbox": [ + 105, + 281, + 506, + 293 + ], + "score": 1.0, + "content": "pushing. In both cases, we feed Visual MPC the subgoal (bidirectional prediction object locations)", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 291, + 506, + 304 + ], + "spans": [ + { + "bbox": [ + 105, + 291, + 153, + 304 + ], + "score": 1.0, + "content": "for the first", + "type": "text" + }, + { + "bbox": [ + 154, + 291, + 173, + 303 + ], + "score": 0.88, + "content": "B / 2", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 291, + 408, + 304 + ], + "score": 1.0, + "content": "timesteps, and then feed the final goal location for the last", + "type": "text" + }, + { + "bbox": [ + 408, + 291, + 428, + 303 + ], + "score": 0.89, + "content": "B / 2", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 291, + 506, + 304 + ], + "score": 1.0, + "content": "steps. The “direct”", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 303, + 505, + 315 + ], + "spans": [ + { + "bbox": [ + 105, + 303, + 361, + 315 + ], + "score": 1.0, + "content": "planning baseline instead receives the final goal location for all", + "type": "text" + }, + { + "bbox": [ + 361, + 303, + 370, + 313 + ], + "score": 0.8, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 371, + 303, + 505, + 315 + ], + "score": 1.0, + "content": "steps. As shown by the results in", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 313, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 106, + 313, + 505, + 326 + ], + "score": 1.0, + "content": "the paper, our subgoal predictions aid in performing these multi-stage pushing tasks better than with", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 325, + 220, + 336 + ], + "spans": [ + { + "bbox": [ + 106, + 325, + 220, + 336 + ], + "score": 1.0, + "content": "the direct planning baseline.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18.5 + }, + { + "type": "title", + "bbox": [ + 107, + 352, + 345, + 365 + ], + "lines": [ + { + "bbox": [ + 105, + 351, + 346, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 346, + 367 + ], + "score": 1.0, + "content": "H SUPPLEMENTARY PREDICTION EXAMPLES", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 106, + 377, + 504, + 399 + ], + "lines": [ + { + "bbox": [ + 106, + 377, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 106, + 377, + 505, + 389 + ], + "score": 1.0, + "content": "We now show more prediction results from various settings in Figs 13, 14, 15, 16, and 17, to", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 388, + 216, + 400 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 216, + 400 + ], + "score": 1.0, + "content": "supplement those in Sec 4.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5 + } + ], + "page_idx": 14, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 170 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "score": 1.0, + "content": "Visual MPC requires start and goal locations of objects to plan. When used in conjunction with our", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 105 + ], + "score": 1.0, + "content": "method, we first compute the locations of objects at the bidirectional predictions and feed this in", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 505, + 117 + ], + "score": 1.0, + "content": "place of the final goal object locations, so that Visual MPC may plan to first reach the bidirectional", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 506, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 506, + 128 + ], + "score": 1.0, + "content": "prediction as a subgoal/stepping stone towards the final goal. Once the subgoal is reached, Visual", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 506, + 140 + ], + "score": 1.0, + "content": "MPC is fed the final goal. To compute subgoal object locations, we use the same technique as in", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 136, + 505, + 151 + ], + "spans": [ + { + "bbox": [ + 105, + 136, + 505, + 151 + ], + "score": 1.0, + "content": "Appendix F above—one-hot maps of object locations are transformed by the appearance flow maps", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 149, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 444, + 162 + ], + "score": 1.0, + "content": "and masks computed internally by our predictor. This produces a probability map", + "type": "text" + }, + { + "bbox": [ + 444, + 150, + 456, + 161 + ], + "score": 0.85, + "content": "p _ { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 149, + 505, + 162 + ], + "score": 1.0, + "content": "over object", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 344, + 171 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 344, + 171 + ], + "score": 1.0, + "content": "locations at the prediction, which is passed to Visual MPC.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 82, + 506, + 171 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 176, + 505, + 264 + ], + "lines": [ + { + "bbox": [ + 106, + 176, + 505, + 188 + ], + "spans": [ + { + "bbox": [ + 106, + 176, + 505, + 188 + ], + "score": 1.0, + "content": "Internally, the Visual MPC planner makes fixed-time forward predictions for the object locations", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 504, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 249, + 200 + ], + "score": 1.0, + "content": "starting from the initial distribution", + "type": "text" + }, + { + "bbox": [ + 250, + 189, + 260, + 199 + ], + "score": 0.86, + "content": "p _ { s }", + "type": "inline_equation" + }, + { + "bbox": [ + 261, + 187, + 473, + 200 + ], + "score": 1.0, + "content": "given a randomly sampled action sequence of length", + "type": "text" + }, + { + "bbox": [ + 474, + 187, + 504, + 198 + ], + "score": 0.89, + "content": "h = 1 5", + "type": "inline_equation" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 505, + 210 + ], + "score": 1.0, + "content": "(the “planning horizon”). Out of all the action sequences, it selects the sequence that brings the", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 209, + 506, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 194, + 222 + ], + "score": 1.0, + "content": "distribution closest to", + "type": "text" + }, + { + "bbox": [ + 195, + 211, + 206, + 221 + ], + "score": 0.86, + "content": "p _ { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 206, + 209, + 235, + 222 + ], + "score": 1.0, + "content": "within", + "type": "text" + }, + { + "bbox": [ + 235, + 209, + 266, + 219 + ], + "score": 0.9, + "content": "h = 1 5", + "type": "inline_equation" + }, + { + "bbox": [ + 266, + 209, + 292, + 222 + ], + "score": 1.0, + "content": "steps", + "type": "text" + }, + { + "bbox": [ + 293, + 210, + 299, + 219 + ], + "score": 0.72, + "content": "h", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 209, + 506, + 222 + ], + "score": 1.0, + "content": "is the “planning horizon”). In practice, we use 200", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 220, + 505, + 232 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 505, + 232 + ], + "score": 1.0, + "content": "random action sequences and perform three iterations of CEM search (Kroese et al., 2013) to find the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 232, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 106, + 232, + 505, + 243 + ], + "score": 1.0, + "content": "the best sequence. Once an action sequence is selected, the first action in the sequence is executed,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 242, + 505, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 505, + 254 + ], + "score": 1.0, + "content": "and the initial object distribution is updated. New candidate action sequences are now generated", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 253, + 384, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 253, + 384, + 266 + ], + "score": 1.0, + "content": "starting from this updated object distribution and the process repeats.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 176, + 506, + 266 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 270, + 505, + 336 + ], + "lines": [ + { + "bbox": [ + 106, + 269, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 106, + 269, + 268, + 282 + ], + "score": 1.0, + "content": "In our experiments, we use a time budget", + "type": "text" + }, + { + "bbox": [ + 268, + 270, + 278, + 280 + ], + "score": 0.81, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 269, + 505, + 282 + ], + "score": 1.0, + "content": "of 40 steps for 2-object pushing, and 75 steps for 3-object", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 281, + 506, + 293 + ], + "spans": [ + { + "bbox": [ + 105, + 281, + 506, + 293 + ], + "score": 1.0, + "content": "pushing. In both cases, we feed Visual MPC the subgoal (bidirectional prediction object locations)", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 291, + 506, + 304 + ], + "spans": [ + { + "bbox": [ + 105, + 291, + 153, + 304 + ], + "score": 1.0, + "content": "for the first", + "type": "text" + }, + { + "bbox": [ + 154, + 291, + 173, + 303 + ], + "score": 0.88, + "content": "B / 2", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 291, + 408, + 304 + ], + "score": 1.0, + "content": "timesteps, and then feed the final goal location for the last", + "type": "text" + }, + { + "bbox": [ + 408, + 291, + 428, + 303 + ], + "score": 0.89, + "content": "B / 2", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 291, + 506, + 304 + ], + "score": 1.0, + "content": "steps. The “direct”", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 303, + 505, + 315 + ], + "spans": [ + { + "bbox": [ + 105, + 303, + 361, + 315 + ], + "score": 1.0, + "content": "planning baseline instead receives the final goal location for all", + "type": "text" + }, + { + "bbox": [ + 361, + 303, + 370, + 313 + ], + "score": 0.8, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 371, + 303, + 505, + 315 + ], + "score": 1.0, + "content": "steps. As shown by the results in", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 313, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 106, + 313, + 505, + 326 + ], + "score": 1.0, + "content": "the paper, our subgoal predictions aid in performing these multi-stage pushing tasks better than with", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 325, + 220, + 336 + ], + "spans": [ + { + "bbox": [ + 106, + 325, + 220, + 336 + ], + "score": 1.0, + "content": "the direct planning baseline.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18.5, + "bbox_fs": [ + 105, + 269, + 506, + 336 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 352, + 345, + 365 + ], + "lines": [ + { + "bbox": [ + 105, + 351, + 346, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 346, + 367 + ], + "score": 1.0, + "content": "H SUPPLEMENTARY PREDICTION EXAMPLES", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 106, + 377, + 504, + 399 + ], + "lines": [ + { + "bbox": [ + 106, + 377, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 106, + 377, + 505, + 389 + ], + "score": 1.0, + "content": "We now show more prediction results from various settings in Figs 13, 14, 15, 16, and 17, to", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 388, + 216, + 400 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 216, + 400 + ], + "score": 1.0, + "content": "supplement those in Sec 4.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 377, + 505, + 400 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 144, + 133, + 464, + 650 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 144, + 133, + 464, + 650 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 144, + 133, + 464, + 650 + ], + "spans": [ + { + "bbox": [ + 144, + 133, + 464, + 650 + ], + "score": 0.96, + "type": "image", + "image_path": "331e0f729cf40eff5b382bbf06438a664d492baeae26a68992e41a0ef5ac3d03.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 144, + 133, + 464, + 305.33333333333337 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 144, + 305.33333333333337, + 464, + 477.66666666666674 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 144, + 477.66666666666674, + 464, + 650.0000000000001 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 655, + 505, + 696 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "Figure 13: (Same format as Fig 6). Supplementary bidirectional prediction results comparing fixed-time", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 666, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 505, + 677 + ], + "score": 1.0, + "content": "prediction and our approach on grasping. First two columns are inputs (start and goal). Thereafter, each column", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 675, + 505, + 687 + ], + "spans": [ + { + "bbox": [ + 106, + 675, + 505, + 687 + ], + "score": 1.0, + "content": "corresponds to the output of a different model per the column title. “match” is the ground truth image closest to", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 685, + 194, + 697 + ], + "spans": [ + { + "bbox": [ + 106, + 685, + 194, + 697 + ], + "score": 1.0, + "content": "the GENMIN prediction.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + } + ], + "page_idx": 15, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "16", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 144, + 133, + 464, + 650 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 144, + 133, + 464, + 650 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 144, + 133, + 464, + 650 + ], + "spans": [ + { + "bbox": [ + 144, + 133, + 464, + 650 + ], + "score": 0.96, + "type": "image", + "image_path": "331e0f729cf40eff5b382bbf06438a664d492baeae26a68992e41a0ef5ac3d03.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 144, + 133, + 464, + 305.33333333333337 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 144, + 305.33333333333337, + 464, + 477.66666666666674 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 144, + 477.66666666666674, + 464, + 650.0000000000001 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 655, + 505, + 696 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "Figure 13: (Same format as Fig 6). Supplementary bidirectional prediction results comparing fixed-time", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 666, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 505, + 677 + ], + "score": 1.0, + "content": "prediction and our approach on grasping. First two columns are inputs (start and goal). Thereafter, each column", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 675, + 505, + 687 + ], + "spans": [ + { + "bbox": [ + 106, + 675, + 505, + 687 + ], + "score": 1.0, + "content": "corresponds to the output of a different model per the column title. “match” is the ground truth image closest to", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 685, + 194, + 697 + ], + "spans": [ + { + "bbox": [ + 106, + 685, + 194, + 697 + ], + "score": 1.0, + "content": "the GENMIN prediction.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 144, + 131, + 464, + 650 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 144, + 131, + 464, + 650 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 144, + 131, + 464, + 650 + ], + "spans": [ + { + "bbox": [ + 144, + 131, + 464, + 650 + ], + "score": 0.958, + "type": "image", + "image_path": "4c02c50243df3f49393e35f68fcbe9a306dde711b7ab7db4fa781dd6ed57197c.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 144, + 131, + 464, + 304.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 144, + 304.0, + 464, + 477.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 144, + 477.0, + 464, + 650.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 655, + 505, + 696 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 655, + 506, + 668 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 506, + 668 + ], + "score": 1.0, + "content": "Figure 14: (Same format as Fig 6). Supplementary bidirectional prediction results comparing fixed-time", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 665, + 506, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 677 + ], + "score": 1.0, + "content": "prediction and our approach on pick-and-place. First two columns are inputs (start and goal). Thereafter, each", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 674, + 505, + 688 + ], + "spans": [ + { + "bbox": [ + 105, + 674, + 505, + 688 + ], + "score": 1.0, + "content": "column corresponds to the output of a different model per the column title. “match” is the ground truth image", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 685, + 230, + 697 + ], + "spans": [ + { + "bbox": [ + 106, + 685, + 230, + 697 + ], + "score": 1.0, + "content": "closest to the GENMIN prediction.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + } + ], + "page_idx": 16, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 144, + 131, + 464, + 650 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 144, + 131, + 464, + 650 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 144, + 131, + 464, + 650 + ], + "spans": [ + { + "bbox": [ + 144, + 131, + 464, + 650 + ], + "score": 0.958, + "type": "image", + "image_path": "4c02c50243df3f49393e35f68fcbe9a306dde711b7ab7db4fa781dd6ed57197c.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 144, + 131, + 464, + 304.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 144, + 304.0, + 464, + 477.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 144, + 477.0, + 464, + 650.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 655, + 505, + 696 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 655, + 506, + 668 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 506, + 668 + ], + "score": 1.0, + "content": "Figure 14: (Same format as Fig 6). Supplementary bidirectional prediction results comparing fixed-time", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 665, + 506, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 677 + ], + "score": 1.0, + "content": "prediction and our approach on pick-and-place. First two columns are inputs (start and goal). Thereafter, each", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 674, + 505, + 688 + ], + "spans": [ + { + "bbox": [ + 105, + 674, + 505, + 688 + ], + "score": 1.0, + "content": "column corresponds to the output of a different model per the column title. “match” is the ground truth image", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 685, + 230, + 697 + ], + "spans": [ + { + "bbox": [ + 106, + 685, + 230, + 697 + ], + "score": 1.0, + "content": "closest to the GENMIN prediction.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 0, + 168, + 595, + 613 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 0, + 168, + 595, + 613 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 0, + 168, + 595, + 613 + ], + "spans": [ + { + "bbox": [ + 0, + 168, + 595, + 613 + ], + "score": 0.965, + "type": "image", + "image_path": "7608e21d6351de86eb9561103060c7e34e988b183e26ac97471c7f928e861972.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 0, + 168, + 595, + 316.33333333333337 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 0, + 316.33333333333337, + 595, + 464.66666666666674 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 0, + 464.66666666666674, + 595, + 613.0000000000001 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 618, + 504, + 650 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 618, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 106, + 618, + 505, + 630 + ], + "score": 1.0, + "content": "Figure 15: Supplementary bidirectional prediction results on pushing. Four columns for each method correspond", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 629, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 106, + 629, + 505, + 640 + ], + "score": 1.0, + "content": "to masked warped start frame, masked warped goal frame, masked new pixels, and final output respectively. See", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 639, + 366, + 651 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 366, + 651 + ], + "score": 1.0, + "content": "Appendix C and Fig 12 for the synthesis scheme with masks and warps.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + } + ], + "page_idx": 17, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 38 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 763 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 763 + ], + "score": 1.0, + "content": "18", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 0, + 168, + 595, + 613 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 0, + 168, + 595, + 613 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 0, + 168, + 595, + 613 + ], + "spans": [ + { + "bbox": [ + 0, + 168, + 595, + 613 + ], + "score": 0.965, + "type": "image", + "image_path": "7608e21d6351de86eb9561103060c7e34e988b183e26ac97471c7f928e861972.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 0, + 168, + 595, + 316.33333333333337 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 0, + 316.33333333333337, + 595, + 464.66666666666674 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 0, + 464.66666666666674, + 595, + 613.0000000000001 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 618, + 504, + 650 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 618, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 106, + 618, + 505, + 630 + ], + "score": 1.0, + "content": "Figure 15: Supplementary bidirectional prediction results on pushing. Four columns for each method correspond", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 629, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 106, + 629, + 505, + 640 + ], + "score": 1.0, + "content": "to masked warped start frame, masked warped goal frame, masked new pixels, and final output respectively. See", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 639, + 366, + 651 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 366, + 651 + ], + "score": 1.0, + "content": "Appendix C and Fig 12 for the synthesis scheme with masks and warps.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 41, + 166, + 558, + 612 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 41, + 166, + 558, + 612 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 41, + 166, + 558, + 612 + ], + "spans": [ + { + "bbox": [ + 41, + 166, + 558, + 612 + ], + "score": 0.967, + "type": "image", + "image_path": "ef3dab5ffbd647668dd9b6a11921ad8c76166914d6c8c768742020a369945769.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 41, + 166, + 558, + 314.66666666666663 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 41, + 314.66666666666663, + 558, + 463.33333333333326 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 41, + 463.33333333333326, + 558, + 611.9999999999999 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 618, + 506, + 660 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 619, + 505, + 631 + ], + "spans": [ + { + "bbox": [ + 106, + 619, + 455, + 631 + ], + "score": 1.0, + "content": "Figure 16: Supplementary bidirectional prediction examples for pick-and-place with GENMIN", + "type": "text" + }, + { + "bbox": [ + 455, + 621, + 461, + 628 + ], + "score": 0.42, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 619, + 505, + 631 + ], + "score": 1.0, + "content": "VAE. Same", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 628, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 106, + 628, + 417, + 641 + ], + "score": 1.0, + "content": "format as Fig 9. Each row is a separate example. First column is the input. GENMIN", + "type": "text" + }, + { + "bbox": [ + 417, + 630, + 424, + 637 + ], + "score": 0.37, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 628, + 505, + 641 + ], + "score": 1.0, + "content": "VAE captures residual", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 250, + 650 + ], + "score": 1.0, + "content": "stochasticity at the bottleneck. GENMIN", + "type": "text" + }, + { + "bbox": [ + 250, + 640, + 257, + 648 + ], + "score": 0.43, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 639, + 505, + 650 + ], + "score": 1.0, + "content": "VAE produces images that are most all of the arm in contact with the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 649, + 442, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 442, + 661 + ], + "score": 1.0, + "content": "object on the table, but at different points on the object, and with different arm/gripper poses.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + } + ], + "page_idx": 18, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "19", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 41, + 166, + 558, + 612 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 41, + 166, + 558, + 612 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 41, + 166, + 558, + 612 + ], + "spans": [ + { + "bbox": [ + 41, + 166, + 558, + 612 + ], + "score": 0.967, + "type": "image", + "image_path": "ef3dab5ffbd647668dd9b6a11921ad8c76166914d6c8c768742020a369945769.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 41, + 166, + 558, + 314.66666666666663 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 41, + 314.66666666666663, + 558, + 463.33333333333326 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 41, + 463.33333333333326, + 558, + 611.9999999999999 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 618, + 506, + 660 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 619, + 505, + 631 + ], + "spans": [ + { + "bbox": [ + 106, + 619, + 455, + 631 + ], + "score": 1.0, + "content": "Figure 16: Supplementary bidirectional prediction examples for pick-and-place with GENMIN", + "type": "text" + }, + { + "bbox": [ + 455, + 621, + 461, + 628 + ], + "score": 0.42, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 619, + 505, + 631 + ], + "score": 1.0, + "content": "VAE. Same", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 628, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 106, + 628, + 417, + 641 + ], + "score": 1.0, + "content": "format as Fig 9. Each row is a separate example. First column is the input. GENMIN", + "type": "text" + }, + { + "bbox": [ + 417, + 630, + 424, + 637 + ], + "score": 0.37, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 628, + 505, + 641 + ], + "score": 1.0, + "content": "VAE captures residual", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 250, + 650 + ], + "score": 1.0, + "content": "stochasticity at the bottleneck. GENMIN", + "type": "text" + }, + { + "bbox": [ + 250, + 640, + 257, + 648 + ], + "score": 0.43, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 639, + 505, + 650 + ], + "score": 1.0, + "content": "VAE produces images that are most all of the arm in contact with the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 649, + 442, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 442, + 661 + ], + "score": 1.0, + "content": "object on the table, but at different points on the object, and with different arm/gripper poses.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 42, + 157, + 559, + 631 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 42, + 157, + 559, + 631 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 42, + 157, + 559, + 631 + ], + "spans": [ + { + "bbox": [ + 42, + 157, + 559, + 631 + ], + "score": 0.965, + "type": "image", + "image_path": "935acf73750df876dda1f586688730675d4fa8665ac4a901053f00f014cd5c71.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 42, + 157, + 559, + 315.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 42, + 315.0, + 559, + 473.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 42, + 473.0, + 559, + 631.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 636, + 505, + 668 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 637, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 505, + 649 + ], + "score": 1.0, + "content": "Figure 17: Supplementary forward prediction examples for grasping, comparing fixed-time predictors and our", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 646, + 506, + 659 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 506, + 659 + ], + "score": 1.0, + "content": "approach. Same format as Fig 5. Each row is a separate example. First column is the input. Thereafter, each", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 657, + 376, + 668 + ], + "spans": [ + { + "bbox": [ + 106, + 657, + 376, + 668 + ], + "score": 1.0, + "content": "column corresponds to the output of a different model per the column title.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + } + ], + "page_idx": 19, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2019", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 298, + 749, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 298, + 749, + 313, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 15 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 42, + 157, + 559, + 631 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 42, + 157, + 559, + 631 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 42, + 157, + 559, + 631 + ], + "spans": [ + { + "bbox": [ + 42, + 157, + 559, + 631 + ], + "score": 0.965, + "type": "image", + "image_path": "935acf73750df876dda1f586688730675d4fa8665ac4a901053f00f014cd5c71.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 42, + 157, + 559, + 315.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 42, + 315.0, + 559, + 473.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 42, + 473.0, + 559, + 631.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 636, + 505, + 668 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 637, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 505, + 649 + ], + "score": 1.0, + "content": "Figure 17: Supplementary forward prediction examples for grasping, comparing fixed-time predictors and our", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 646, + 506, + 659 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 506, + 659 + ], + "score": 1.0, + "content": "approach. Same format as Fig 5. Each row is a separate example. First column is the input. Thereafter, each", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 657, + 376, + 668 + ], + "spans": [ + { + "bbox": [ + 106, + 657, + 376, + 668 + ], + "score": 1.0, + "content": "column corresponds to the output of a different model per the column title.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file