diff --git "a/parse/train/4AWko4A35ss/4AWko4A35ss_middle.json" "b/parse/train/4AWko4A35ss/4AWko4A35ss_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/4AWko4A35ss/4AWko4A35ss_middle.json" @@ -0,0 +1,39506 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 503, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 78, + 505, + 97 + ], + "spans": [ + { + "bbox": [ + 106, + 78, + 505, + 97 + ], + "score": 1.0, + "content": "SELF-SUPERVISED VIDEO REPRESENTATION LEARN-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 99, + 489, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 99, + 489, + 118 + ], + "score": 1.0, + "content": "ING WITH CONSTRAINED SPATIOTEMPORAL JIGSAW", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 112, + 136, + 244, + 157 + ], + "lines": [ + { + "bbox": [ + 113, + 136, + 201, + 147 + ], + "spans": [ + { + "bbox": [ + 113, + 136, + 201, + 147 + ], + "score": 1.0, + "content": "Anonymous authors", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 112, + 146, + 245, + 159 + ], + "spans": [ + { + "bbox": [ + 112, + 146, + 245, + 159 + ], + "score": 1.0, + "content": "Paper under double-blind review", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5 + }, + { + "type": "title", + "bbox": [ + 278, + 186, + 333, + 199 + ], + "lines": [ + { + "bbox": [ + 276, + 186, + 335, + 200 + ], + "spans": [ + { + "bbox": [ + 276, + 186, + 335, + 200 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 143, + 210, + 468, + 374 + ], + "lines": [ + { + "bbox": [ + 141, + 210, + 469, + 222 + ], + "spans": [ + { + "bbox": [ + 141, + 210, + 469, + 222 + ], + "score": 1.0, + "content": "This paper proposes a novel pretext task for self-supervised video representation", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 221, + 470, + 234 + ], + "spans": [ + { + "bbox": [ + 141, + 221, + 470, + 234 + ], + "score": 1.0, + "content": "learning by exploiting spatiotemporal continuity in videos. It is motivated by the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 231, + 470, + 244 + ], + "spans": [ + { + "bbox": [ + 141, + 231, + 470, + 244 + ], + "score": 1.0, + "content": "fact that videos are spatiotemporal by nature and a representation learned to detect", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 243, + 470, + 255 + ], + "spans": [ + { + "bbox": [ + 141, + 243, + 470, + 255 + ], + "score": 1.0, + "content": "spatiotemporal continuity/discontinuity is thus beneficial for downstream video", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 253, + 469, + 267 + ], + "spans": [ + { + "bbox": [ + 141, + 253, + 469, + 267 + ], + "score": 1.0, + "content": "content analysis tasks. A natural choice of such a pretext task is to construct spa-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 264, + 470, + 277 + ], + "spans": [ + { + "bbox": [ + 141, + 264, + 470, + 277 + ], + "score": 1.0, + "content": "tiotemporal (3D) jigsaw puzzles and learn to solve them. However, this task turns", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 276, + 469, + 288 + ], + "spans": [ + { + "bbox": [ + 141, + 276, + 469, + 288 + ], + "score": 1.0, + "content": "out to be intractable. We thus propose Constrained Spatiotemporal Jigsaw (CSJ)", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 286, + 470, + 299 + ], + "spans": [ + { + "bbox": [ + 141, + 286, + 470, + 299 + ], + "score": 1.0, + "content": "whereby the 3D jigsaws are formed in a constrained manner to ensure that large", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 142, + 298, + 470, + 309 + ], + "spans": [ + { + "bbox": [ + 142, + 298, + 470, + 309 + ], + "score": 1.0, + "content": "continuous spatiotemporal cuboids exist in a shuffled clip to provide sufficient", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 309, + 469, + 321 + ], + "spans": [ + { + "bbox": [ + 141, + 309, + 469, + 321 + ], + "score": 1.0, + "content": "cues for the model to reason about the continuity. With the constrained jigsaw", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 320, + 469, + 331 + ], + "spans": [ + { + "bbox": [ + 141, + 320, + 469, + 331 + ], + "score": 1.0, + "content": "puzzles, instead of solving them directly, which could still be extremely hard, we", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 330, + 469, + 343 + ], + "spans": [ + { + "bbox": [ + 141, + 330, + 469, + 343 + ], + "score": 1.0, + "content": "carefully design four surrogate tasks that are more solvable but meanwhile still", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 341, + 470, + 354 + ], + "spans": [ + { + "bbox": [ + 141, + 341, + 470, + 354 + ], + "score": 1.0, + "content": "ensure that the learned representation is sensitive to spatiotemporal continuity at", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 142, + 353, + 469, + 364 + ], + "spans": [ + { + "bbox": [ + 142, + 353, + 469, + 364 + ], + "score": 1.0, + "content": "both the local and global levels. Extensive experiments show that our CSJ achieves", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 142, + 363, + 419, + 375 + ], + "spans": [ + { + "bbox": [ + 142, + 363, + 419, + 375 + ], + "score": 1.0, + "content": "state-of-the-art on two downstream tasks across various benchmarks.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 12 + }, + { + "type": "title", + "bbox": [ + 108, + 393, + 206, + 406 + ], + "lines": [ + { + "bbox": [ + 105, + 392, + 208, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 392, + 208, + 409 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 417, + 504, + 484 + ], + "lines": [ + { + "bbox": [ + 105, + 417, + 506, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 417, + 506, + 430 + ], + "score": 1.0, + "content": "Self-supervised learning (SSL) has achieved tremendous successes recently for static images (He", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 429, + 505, + 441 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 505, + 441 + ], + "score": 1.0, + "content": "et al., 2020; Chen et al., 2020) and shown to be able to outperform supervised learning on a wide", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 440, + 505, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 505, + 452 + ], + "score": 1.0, + "content": "range of downstream image understanding tasks. However, such successes have not yet been re-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 450, + 506, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 506, + 463 + ], + "score": 1.0, + "content": "produced for videos. Since different SSL models differ mostly on the pretext tasks employed on", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 461, + 506, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 506, + 474 + ], + "score": 1.0, + "content": "the unlabeled training data, designing pretext tasks more suitable for videos is the current focus for", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 472, + 438, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 438, + 484 + ], + "score": 1.0, + "content": "self-supervised video representation learning (Han et al., 2020; Wang et al., 2020).", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 107, + 489, + 505, + 588 + ], + "lines": [ + { + "bbox": [ + 106, + 489, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 505, + 502 + ], + "score": 1.0, + "content": "Videos are spatiotemporal data and spatiotemporal analysis is the key to many video content un-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 501, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 106, + 501, + 505, + 513 + ], + "score": 1.0, + "content": "derstanding tasks. A good video representation learned from the self-supervised pretext task should", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 511, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 523 + ], + "score": 1.0, + "content": "therefore capture discriminative information jointly along both spatial and temporal dimensions. It", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 522, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 505, + 535 + ], + "score": 1.0, + "content": "is thus somewhat counter-intuitive to note that most existing SSL pretext tasks for videos do not", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 534, + 505, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 505, + 547 + ], + "score": 1.0, + "content": "explicitly require joint spatiotemporal video understanding. For example, some spatial pretext tasks", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 543, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 505, + 558 + ], + "score": 1.0, + "content": "have been borrowed from images without any modification (Jing et al., 2018), ignoring the temporal", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 554, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 505, + 568 + ], + "score": 1.0, + "content": "dimension. On the other hand, many recent video-specific pretext tasks typically involve speed or", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 565, + 506, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 506, + 580 + ], + "score": 1.0, + "content": "temporal order prediction (Lee et al., 2017; Wei et al., 2018; Benaim et al., 2020; Wang et al., 2020),", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 577, + 321, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 321, + 590 + ], + "score": 1.0, + "content": "i.e., operating predominately along the temporal axis.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 594, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 594, + 505, + 607 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 505, + 607 + ], + "score": 1.0, + "content": "A natural choice for a spatiotemporal pretext task is to solve 3D jigsaw puzzles, whose 2D counter-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 605, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 505, + 618 + ], + "score": 1.0, + "content": "part has been successfully used for images (Noroozi & Favaro, 2016). Indeed, solving 3D puzzles", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 616, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 505, + 629 + ], + "score": 1.0, + "content": "requires the learned model to understand spatiotemporal continuity, a key step towards video con-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 626, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 506, + 640 + ], + "score": 1.0, + "content": "tent understanding. However, directly solving a 3D puzzle turns out to be intractable: a puzzle of", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 638, + 138, + 649 + ], + "score": 0.88, + "content": "3 \\times 3 \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 639, + 505, + 650 + ], + "score": 1.0, + "content": "pieces (the same size as a Rubik’s cube) can have 27! possible permutations. Video volume", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "even in a short clip is much larger than that. Nevertheless, the latest neural sorting models (Paumard", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "et al., 2020; Du et al., 2020) can only handle permutations a few orders of magnitude less, so offer", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 671, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 505, + 684 + ], + "score": 1.0, + "content": "no solution. This is hardly surprising because such a task is daunting even for humans: Most people", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 681, + 402, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 402, + 695 + ], + "score": 1.0, + "content": "would struggle with a standard Rubik’s cube, let alone a much larger one.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "In this paper, we propose a novel Constrained Spatiotemporal Jigsaw (CSJ) pretext task for self-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "supervised video representation learning. The key idea is to form 3D jigsaw puzzles in a constrained", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 720, + 504, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 504, + 733 + ], + "score": 1.0, + "content": "manner so that it becomes solvable. This is achieved by factorizing the permutations (shuffling)", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 46 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 303, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 308, + 761 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 308, + 761 + ], + "score": 1.0, + "content": "1", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 503, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 78, + 505, + 97 + ], + "spans": [ + { + "bbox": [ + 106, + 78, + 505, + 97 + ], + "score": 1.0, + "content": "SELF-SUPERVISED VIDEO REPRESENTATION LEARN-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 99, + 489, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 99, + 489, + 118 + ], + "score": 1.0, + "content": "ING WITH CONSTRAINED SPATIOTEMPORAL JIGSAW", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 112, + 136, + 244, + 157 + ], + "lines": [ + { + "bbox": [ + 113, + 136, + 201, + 147 + ], + "spans": [ + { + "bbox": [ + 113, + 136, + 201, + 147 + ], + "score": 1.0, + "content": "Anonymous authors", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 112, + 146, + 245, + 159 + ], + "spans": [ + { + "bbox": [ + 112, + 146, + 245, + 159 + ], + "score": 1.0, + "content": "Paper under double-blind review", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5, + "bbox_fs": [ + 112, + 136, + 245, + 159 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 186, + 333, + 199 + ], + "lines": [ + { + "bbox": [ + 276, + 186, + 335, + 200 + ], + "spans": [ + { + "bbox": [ + 276, + 186, + 335, + 200 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 143, + 210, + 468, + 374 + ], + "lines": [ + { + "bbox": [ + 141, + 210, + 469, + 222 + ], + "spans": [ + { + "bbox": [ + 141, + 210, + 469, + 222 + ], + "score": 1.0, + "content": "This paper proposes a novel pretext task for self-supervised video representation", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 221, + 470, + 234 + ], + "spans": [ + { + "bbox": [ + 141, + 221, + 470, + 234 + ], + "score": 1.0, + "content": "learning by exploiting spatiotemporal continuity in videos. It is motivated by the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 231, + 470, + 244 + ], + "spans": [ + { + "bbox": [ + 141, + 231, + 470, + 244 + ], + "score": 1.0, + "content": "fact that videos are spatiotemporal by nature and a representation learned to detect", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 243, + 470, + 255 + ], + "spans": [ + { + "bbox": [ + 141, + 243, + 470, + 255 + ], + "score": 1.0, + "content": "spatiotemporal continuity/discontinuity is thus beneficial for downstream video", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 253, + 469, + 267 + ], + "spans": [ + { + "bbox": [ + 141, + 253, + 469, + 267 + ], + "score": 1.0, + "content": "content analysis tasks. A natural choice of such a pretext task is to construct spa-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 264, + 470, + 277 + ], + "spans": [ + { + "bbox": [ + 141, + 264, + 470, + 277 + ], + "score": 1.0, + "content": "tiotemporal (3D) jigsaw puzzles and learn to solve them. However, this task turns", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 276, + 469, + 288 + ], + "spans": [ + { + "bbox": [ + 141, + 276, + 469, + 288 + ], + "score": 1.0, + "content": "out to be intractable. We thus propose Constrained Spatiotemporal Jigsaw (CSJ)", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 286, + 470, + 299 + ], + "spans": [ + { + "bbox": [ + 141, + 286, + 470, + 299 + ], + "score": 1.0, + "content": "whereby the 3D jigsaws are formed in a constrained manner to ensure that large", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 142, + 298, + 470, + 309 + ], + "spans": [ + { + "bbox": [ + 142, + 298, + 470, + 309 + ], + "score": 1.0, + "content": "continuous spatiotemporal cuboids exist in a shuffled clip to provide sufficient", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 309, + 469, + 321 + ], + "spans": [ + { + "bbox": [ + 141, + 309, + 469, + 321 + ], + "score": 1.0, + "content": "cues for the model to reason about the continuity. With the constrained jigsaw", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 320, + 469, + 331 + ], + "spans": [ + { + "bbox": [ + 141, + 320, + 469, + 331 + ], + "score": 1.0, + "content": "puzzles, instead of solving them directly, which could still be extremely hard, we", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 330, + 469, + 343 + ], + "spans": [ + { + "bbox": [ + 141, + 330, + 469, + 343 + ], + "score": 1.0, + "content": "carefully design four surrogate tasks that are more solvable but meanwhile still", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 341, + 470, + 354 + ], + "spans": [ + { + "bbox": [ + 141, + 341, + 470, + 354 + ], + "score": 1.0, + "content": "ensure that the learned representation is sensitive to spatiotemporal continuity at", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 142, + 353, + 469, + 364 + ], + "spans": [ + { + "bbox": [ + 142, + 353, + 469, + 364 + ], + "score": 1.0, + "content": "both the local and global levels. Extensive experiments show that our CSJ achieves", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 142, + 363, + 419, + 375 + ], + "spans": [ + { + "bbox": [ + 142, + 363, + 419, + 375 + ], + "score": 1.0, + "content": "state-of-the-art on two downstream tasks across various benchmarks.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 12, + "bbox_fs": [ + 141, + 210, + 470, + 375 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 393, + 206, + 406 + ], + "lines": [ + { + "bbox": [ + 105, + 392, + 208, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 392, + 208, + 409 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 417, + 504, + 484 + ], + "lines": [ + { + "bbox": [ + 105, + 417, + 506, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 417, + 506, + 430 + ], + "score": 1.0, + "content": "Self-supervised learning (SSL) has achieved tremendous successes recently for static images (He", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 429, + 505, + 441 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 505, + 441 + ], + "score": 1.0, + "content": "et al., 2020; Chen et al., 2020) and shown to be able to outperform supervised learning on a wide", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 440, + 505, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 505, + 452 + ], + "score": 1.0, + "content": "range of downstream image understanding tasks. However, such successes have not yet been re-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 450, + 506, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 506, + 463 + ], + "score": 1.0, + "content": "produced for videos. Since different SSL models differ mostly on the pretext tasks employed on", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 461, + 506, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 506, + 474 + ], + "score": 1.0, + "content": "the unlabeled training data, designing pretext tasks more suitable for videos is the current focus for", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 472, + 438, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 438, + 484 + ], + "score": 1.0, + "content": "self-supervised video representation learning (Han et al., 2020; Wang et al., 2020).", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 417, + 506, + 484 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 489, + 505, + 588 + ], + "lines": [ + { + "bbox": [ + 106, + 489, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 505, + 502 + ], + "score": 1.0, + "content": "Videos are spatiotemporal data and spatiotemporal analysis is the key to many video content un-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 501, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 106, + 501, + 505, + 513 + ], + "score": 1.0, + "content": "derstanding tasks. A good video representation learned from the self-supervised pretext task should", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 511, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 523 + ], + "score": 1.0, + "content": "therefore capture discriminative information jointly along both spatial and temporal dimensions. It", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 522, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 505, + 535 + ], + "score": 1.0, + "content": "is thus somewhat counter-intuitive to note that most existing SSL pretext tasks for videos do not", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 534, + 505, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 505, + 547 + ], + "score": 1.0, + "content": "explicitly require joint spatiotemporal video understanding. For example, some spatial pretext tasks", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 543, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 505, + 558 + ], + "score": 1.0, + "content": "have been borrowed from images without any modification (Jing et al., 2018), ignoring the temporal", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 554, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 505, + 568 + ], + "score": 1.0, + "content": "dimension. On the other hand, many recent video-specific pretext tasks typically involve speed or", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 565, + 506, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 506, + 580 + ], + "score": 1.0, + "content": "temporal order prediction (Lee et al., 2017; Wei et al., 2018; Benaim et al., 2020; Wang et al., 2020),", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 577, + 321, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 321, + 590 + ], + "score": 1.0, + "content": "i.e., operating predominately along the temporal axis.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 31, + "bbox_fs": [ + 105, + 489, + 506, + 590 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 594, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 594, + 505, + 607 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 505, + 607 + ], + "score": 1.0, + "content": "A natural choice for a spatiotemporal pretext task is to solve 3D jigsaw puzzles, whose 2D counter-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 605, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 505, + 618 + ], + "score": 1.0, + "content": "part has been successfully used for images (Noroozi & Favaro, 2016). Indeed, solving 3D puzzles", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 616, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 505, + 629 + ], + "score": 1.0, + "content": "requires the learned model to understand spatiotemporal continuity, a key step towards video con-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 626, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 506, + 640 + ], + "score": 1.0, + "content": "tent understanding. However, directly solving a 3D puzzle turns out to be intractable: a puzzle of", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 638, + 138, + 649 + ], + "score": 0.88, + "content": "3 \\times 3 \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 639, + 505, + 650 + ], + "score": 1.0, + "content": "pieces (the same size as a Rubik’s cube) can have 27! possible permutations. Video volume", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "even in a short clip is much larger than that. Nevertheless, the latest neural sorting models (Paumard", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "et al., 2020; Du et al., 2020) can only handle permutations a few orders of magnitude less, so offer", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 671, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 505, + 684 + ], + "score": 1.0, + "content": "no solution. This is hardly surprising because such a task is daunting even for humans: Most people", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 681, + 402, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 402, + 695 + ], + "score": 1.0, + "content": "would struggle with a standard Rubik’s cube, let alone a much larger one.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 40, + "bbox_fs": [ + 105, + 594, + 506, + 695 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "In this paper, we propose a novel Constrained Spatiotemporal Jigsaw (CSJ) pretext task for self-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "supervised video representation learning. The key idea is to form 3D jigsaw puzzles in a constrained", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 720, + 504, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 504, + 733 + ], + "score": 1.0, + "content": "manner so that it becomes solvable. This is achieved by factorizing the permutations (shuffling)", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 46, + "bbox_fs": [ + 105, + 698, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 109, + 82, + 499, + 164 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 82, + 499, + 164 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 82, + 499, + 164 + ], + "spans": [ + { + "bbox": [ + 109, + 82, + 499, + 164 + ], + "score": 0.971, + "type": "image", + "image_path": "0e2765ac1fc37cb3ed7161a49676d6807733f039ef6007ddb1e38232e0101f70.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 109, + 82, + 499, + 109.33333333333333 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 109, + 109.33333333333333, + 499, + 136.66666666666666 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 109, + 136.66666666666666, + 499, + 164.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 169, + 505, + 268 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 168, + 505, + 182 + ], + "spans": [ + { + "bbox": [ + 105, + 168, + 505, + 182 + ], + "score": 1.0, + "content": "Figure 1: Illustration of our constrained jigsaw and the surrogate pretext tasks using an image ex-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 180, + 505, + 192 + ], + "spans": [ + { + "bbox": [ + 106, + 180, + 505, + 192 + ], + "score": 1.0, + "content": "ample (only spatial for clarity). Our constrained jigsaw can be easily extended to the spatiotemporal", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 190, + 506, + 204 + ], + "spans": [ + { + "bbox": [ + 105, + 190, + 506, + 204 + ], + "score": 1.0, + "content": "domain as done in this work. (a): The raw image. (b),(c): Comparing an unconstrained puzzle", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 202, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 106, + 202, + 505, + 214 + ], + "score": 1.0, + "content": "(b) and our constrained one (c), it is clear that ours is much more continuous (hence interpretable)", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 212, + 505, + 226 + ], + "spans": [ + { + "bbox": [ + 105, + 212, + 505, + 226 + ], + "score": 1.0, + "content": "reflected by the size of the largest continuous cuboids (LCCs, rectangles in images here) shown in", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 222, + 506, + 237 + ], + "spans": [ + { + "bbox": [ + 104, + 222, + 506, + 237 + ], + "score": 1.0, + "content": "red. (d),(e): Illustration of the importance of the relative order of the top-2 LCCs for determining", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 104, + 234, + 505, + 249 + ], + "spans": [ + { + "bbox": [ + 104, + 234, + 505, + 249 + ], + "score": 1.0, + "content": "the global continuity level of the shuffled image. (d) and (e) have the same top-2 LCCs, but only", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 244, + 506, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 506, + 259 + ], + "score": 1.0, + "content": "(d) keeps the correct relative order between them. Locating these LCCs and predicting their relative", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 257, + 328, + 268 + ], + "spans": [ + { + "bbox": [ + 106, + 257, + 328, + 268 + ], + "score": 1.0, + "content": "order are thus the key objectives of our surrogate tasks.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 7 + } + ], + "index": 4.0 + }, + { + "type": "text", + "bbox": [ + 106, + 284, + 505, + 449 + ], + "lines": [ + { + "bbox": [ + 106, + 284, + 506, + 297 + ], + "spans": [ + { + "bbox": [ + 106, + 284, + 506, + 297 + ], + "score": 1.0, + "content": "into the three spatiotemporal dimensions and then applying them sequentially. This ensures that for", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 295, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 505, + 308 + ], + "score": 1.0, + "content": "a given video clip, large continuous spatiotemporal cuboids exist after the constrained shuffling to", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 306, + 505, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 505, + 319 + ], + "score": 1.0, + "content": "provide sufficient cues for the model to reason about spatiotemporal continuity (see Fig. 1(b)(c)).", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 318, + 505, + 329 + ], + "spans": [ + { + "bbox": [ + 106, + 318, + 505, + 329 + ], + "score": 1.0, + "content": "Such large continuous cuboids are also vital for human understanding of video as revealed in neu-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 328, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 328, + 505, + 340 + ], + "score": 1.0, + "content": "roscience and visual studies (Stringer et al., 2006; Chen et al., 2019). Even with the constrained", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 340, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 505, + 351 + ], + "score": 1.0, + "content": "puzzles, solving them directly could still be extremely hard. Consequently, instead of directly solv-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 350, + 506, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 350, + 506, + 363 + ], + "score": 1.0, + "content": "ing the puzzles (i.e., recovering the permutation matrix so that each piece can be put back), four", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 361, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 505, + 373 + ], + "score": 1.0, + "content": "surrogate tasks are carefully designed. They are more solvable but meanwhile still ensure that the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 372, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 505, + 384 + ], + "score": 1.0, + "content": "learned representation is sensitive to spatiotemporal continuity at both the local and global levels.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 382, + 506, + 396 + ], + "spans": [ + { + "bbox": [ + 105, + 382, + 506, + 396 + ], + "score": 1.0, + "content": "Concretely, given a video clip shuffled with our constrained permutations, we make sure that the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 394, + 506, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 506, + 407 + ], + "score": 1.0, + "content": "top-2 largest continuous cuboids (LCCs) dominate the clip volume. The level of continuity in the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 403, + 505, + 419 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 505, + 419 + ], + "score": 1.0, + "content": "shuffle clip as a whole is thus determined mainly by the volumes of these LCCs, and whether they", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 416, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 505, + 429 + ], + "score": 1.0, + "content": "are at the right order (see Fig. 1(d)(e)) both spatially and temporally. Our surrogate tasks are thus", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 427, + 506, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 506, + 439 + ], + "score": 1.0, + "content": "designed to locate these LCCs and predict their order so that the model learned with these tasks can", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 438, + 373, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 438, + 373, + 451 + ], + "score": 1.0, + "content": "be sensitive to spatiotemporal continuity both locally and globally.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 106, + 454, + 505, + 542 + ], + "lines": [ + { + "bbox": [ + 105, + 454, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 505, + 468 + ], + "score": 1.0, + "content": "Our main contributions are three-fold: (1) We introduce a new pretext task for self-supervised video", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 465, + 504, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 504, + 478 + ], + "score": 1.0, + "content": "representation learning called Constrained Spatiotemporal Jigsaw (CSJ). To our best knowledge,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 476, + 505, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 476, + 505, + 489 + ], + "score": 1.0, + "content": "this is the first work on self-supervised video representation learning that leverages spatiotemporal", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 488, + 506, + 500 + ], + "spans": [ + { + "bbox": [ + 104, + 488, + 506, + 500 + ], + "score": 1.0, + "content": "jigsaw understanding. (2) We propose a novel constrained shuffling method to construct easy 3D", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 498, + 506, + 511 + ], + "spans": [ + { + "bbox": [ + 104, + 498, + 506, + 511 + ], + "score": 1.0, + "content": "jigsaws containing large LCCs. Four surrogate tasks are then formulated in place of the original", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 104, + 509, + 506, + 523 + ], + "spans": [ + { + "bbox": [ + 104, + 509, + 506, + 523 + ], + "score": 1.0, + "content": "jigsaw solving tasks. They are much more solvable yet remain effective in learning spatiotemporal", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 520, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 520, + 505, + 533 + ], + "score": 1.0, + "content": "discriminative representations. (3) Extensive experiments show that our approach achieves state-of-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 532, + 350, + 543 + ], + "spans": [ + { + "bbox": [ + 106, + 532, + 350, + 543 + ], + "score": 1.0, + "content": "the-art on two downstream tasks across various benchmarks.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 30.5 + }, + { + "type": "title", + "bbox": [ + 108, + 562, + 211, + 575 + ], + "lines": [ + { + "bbox": [ + 104, + 560, + 213, + 577 + ], + "spans": [ + { + "bbox": [ + 104, + 560, + 213, + 577 + ], + "score": 1.0, + "content": "2 RELATED WORK", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 106, + 589, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 588, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 506, + 601 + ], + "score": 1.0, + "content": "Self-supervised Learning with Pretext Tasks Self-supervised learning (SSL) typically employs a", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 600, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 505, + 613 + ], + "score": 1.0, + "content": "pretext task to generate pseudo-labels for unlabeled data via some forms of data transformation. Ac-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 611, + 505, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 505, + 624 + ], + "score": 1.0, + "content": "cording to the transformations used by the pretext task, existing SSL methods for video presentation", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 622, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 505, + 635 + ], + "score": 1.0, + "content": "learning can be divided into three categories: (1) Spatial-Only Transformations: Derived from the", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 633, + 505, + 646 + ], + "spans": [ + { + "bbox": [ + 106, + 633, + 505, + 646 + ], + "score": 1.0, + "content": "original image domain (Gidaris et al., 2018), Jing et al. (2018) leveraged the spatial-only transforma-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 643, + 506, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 643, + 506, + 658 + ], + "score": 1.0, + "content": "tions for self-supervised video presentation learning. (2) Temporal-Only Transformations: Misra", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 655, + 505, + 666 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 666 + ], + "score": 1.0, + "content": "et al. (2016); Fernando et al. (2017); Lee et al. (2017); Wei et al. (2018) obtained shuffled video", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 666, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 506, + 678 + ], + "score": 1.0, + "content": "frames with the temporal-only transformations and then distinguished whether the shuffled frames", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "are in chronological order. Xu et al. (2019) chose to shuffle video clips instead of frames. Benaim", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "et al. (2020); Yao et al. (2020); Jenni et al. (2020) exploited the speed transformation via determin-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "ing whether one video clip is accelerated. (3) Spatiotemporal Transformations: There are only a", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "few recent approaches (Ahsan et al., 2019; Kim et al., 2019) that leveraged both spatial and tempo-", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 720, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 734 + ], + "score": 1.0, + "content": "ral transformations by permuting 3D spatiotemporal cuboids. However, due to the aforementioned", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 42 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 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": [ + 109, + 82, + 499, + 164 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 82, + 499, + 164 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 82, + 499, + 164 + ], + "spans": [ + { + "bbox": [ + 109, + 82, + 499, + 164 + ], + "score": 0.971, + "type": "image", + "image_path": "0e2765ac1fc37cb3ed7161a49676d6807733f039ef6007ddb1e38232e0101f70.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 109, + 82, + 499, + 109.33333333333333 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 109, + 109.33333333333333, + 499, + 136.66666666666666 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 109, + 136.66666666666666, + 499, + 164.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 169, + 505, + 268 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 168, + 505, + 182 + ], + "spans": [ + { + "bbox": [ + 105, + 168, + 505, + 182 + ], + "score": 1.0, + "content": "Figure 1: Illustration of our constrained jigsaw and the surrogate pretext tasks using an image ex-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 180, + 505, + 192 + ], + "spans": [ + { + "bbox": [ + 106, + 180, + 505, + 192 + ], + "score": 1.0, + "content": "ample (only spatial for clarity). Our constrained jigsaw can be easily extended to the spatiotemporal", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 190, + 506, + 204 + ], + "spans": [ + { + "bbox": [ + 105, + 190, + 506, + 204 + ], + "score": 1.0, + "content": "domain as done in this work. (a): The raw image. (b),(c): Comparing an unconstrained puzzle", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 202, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 106, + 202, + 505, + 214 + ], + "score": 1.0, + "content": "(b) and our constrained one (c), it is clear that ours is much more continuous (hence interpretable)", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 212, + 505, + 226 + ], + "spans": [ + { + "bbox": [ + 105, + 212, + 505, + 226 + ], + "score": 1.0, + "content": "reflected by the size of the largest continuous cuboids (LCCs, rectangles in images here) shown in", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 222, + 506, + 237 + ], + "spans": [ + { + "bbox": [ + 104, + 222, + 506, + 237 + ], + "score": 1.0, + "content": "red. (d),(e): Illustration of the importance of the relative order of the top-2 LCCs for determining", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 104, + 234, + 505, + 249 + ], + "spans": [ + { + "bbox": [ + 104, + 234, + 505, + 249 + ], + "score": 1.0, + "content": "the global continuity level of the shuffled image. (d) and (e) have the same top-2 LCCs, but only", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 244, + 506, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 506, + 259 + ], + "score": 1.0, + "content": "(d) keeps the correct relative order between them. Locating these LCCs and predicting their relative", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 257, + 328, + 268 + ], + "spans": [ + { + "bbox": [ + 106, + 257, + 328, + 268 + ], + "score": 1.0, + "content": "order are thus the key objectives of our surrogate tasks.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 7 + } + ], + "index": 4.0 + }, + { + "type": "text", + "bbox": [ + 106, + 284, + 505, + 449 + ], + "lines": [ + { + "bbox": [ + 106, + 284, + 506, + 297 + ], + "spans": [ + { + "bbox": [ + 106, + 284, + 506, + 297 + ], + "score": 1.0, + "content": "into the three spatiotemporal dimensions and then applying them sequentially. This ensures that for", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 295, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 505, + 308 + ], + "score": 1.0, + "content": "a given video clip, large continuous spatiotemporal cuboids exist after the constrained shuffling to", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 306, + 505, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 505, + 319 + ], + "score": 1.0, + "content": "provide sufficient cues for the model to reason about spatiotemporal continuity (see Fig. 1(b)(c)).", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 318, + 505, + 329 + ], + "spans": [ + { + "bbox": [ + 106, + 318, + 505, + 329 + ], + "score": 1.0, + "content": "Such large continuous cuboids are also vital for human understanding of video as revealed in neu-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 328, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 328, + 505, + 340 + ], + "score": 1.0, + "content": "roscience and visual studies (Stringer et al., 2006; Chen et al., 2019). Even with the constrained", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 340, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 505, + 351 + ], + "score": 1.0, + "content": "puzzles, solving them directly could still be extremely hard. Consequently, instead of directly solv-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 350, + 506, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 350, + 506, + 363 + ], + "score": 1.0, + "content": "ing the puzzles (i.e., recovering the permutation matrix so that each piece can be put back), four", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 361, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 505, + 373 + ], + "score": 1.0, + "content": "surrogate tasks are carefully designed. They are more solvable but meanwhile still ensure that the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 372, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 505, + 384 + ], + "score": 1.0, + "content": "learned representation is sensitive to spatiotemporal continuity at both the local and global levels.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 382, + 506, + 396 + ], + "spans": [ + { + "bbox": [ + 105, + 382, + 506, + 396 + ], + "score": 1.0, + "content": "Concretely, given a video clip shuffled with our constrained permutations, we make sure that the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 394, + 506, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 506, + 407 + ], + "score": 1.0, + "content": "top-2 largest continuous cuboids (LCCs) dominate the clip volume. The level of continuity in the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 403, + 505, + 419 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 505, + 419 + ], + "score": 1.0, + "content": "shuffle clip as a whole is thus determined mainly by the volumes of these LCCs, and whether they", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 416, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 505, + 429 + ], + "score": 1.0, + "content": "are at the right order (see Fig. 1(d)(e)) both spatially and temporally. Our surrogate tasks are thus", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 427, + 506, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 506, + 439 + ], + "score": 1.0, + "content": "designed to locate these LCCs and predict their order so that the model learned with these tasks can", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 438, + 373, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 438, + 373, + 451 + ], + "score": 1.0, + "content": "be sensitive to spatiotemporal continuity both locally and globally.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 19, + "bbox_fs": [ + 105, + 284, + 506, + 451 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 454, + 505, + 542 + ], + "lines": [ + { + "bbox": [ + 105, + 454, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 505, + 468 + ], + "score": 1.0, + "content": "Our main contributions are three-fold: (1) We introduce a new pretext task for self-supervised video", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 465, + 504, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 504, + 478 + ], + "score": 1.0, + "content": "representation learning called Constrained Spatiotemporal Jigsaw (CSJ). To our best knowledge,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 476, + 505, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 476, + 505, + 489 + ], + "score": 1.0, + "content": "this is the first work on self-supervised video representation learning that leverages spatiotemporal", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 488, + 506, + 500 + ], + "spans": [ + { + "bbox": [ + 104, + 488, + 506, + 500 + ], + "score": 1.0, + "content": "jigsaw understanding. (2) We propose a novel constrained shuffling method to construct easy 3D", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 498, + 506, + 511 + ], + "spans": [ + { + "bbox": [ + 104, + 498, + 506, + 511 + ], + "score": 1.0, + "content": "jigsaws containing large LCCs. Four surrogate tasks are then formulated in place of the original", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 104, + 509, + 506, + 523 + ], + "spans": [ + { + "bbox": [ + 104, + 509, + 506, + 523 + ], + "score": 1.0, + "content": "jigsaw solving tasks. They are much more solvable yet remain effective in learning spatiotemporal", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 520, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 520, + 505, + 533 + ], + "score": 1.0, + "content": "discriminative representations. (3) Extensive experiments show that our approach achieves state-of-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 532, + 350, + 543 + ], + "spans": [ + { + "bbox": [ + 106, + 532, + 350, + 543 + ], + "score": 1.0, + "content": "the-art on two downstream tasks across various benchmarks.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 30.5, + "bbox_fs": [ + 104, + 454, + 506, + 543 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 562, + 211, + 575 + ], + "lines": [ + { + "bbox": [ + 104, + 560, + 213, + 577 + ], + "spans": [ + { + "bbox": [ + 104, + 560, + 213, + 577 + ], + "score": 1.0, + "content": "2 RELATED WORK", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 106, + 589, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 588, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 506, + 601 + ], + "score": 1.0, + "content": "Self-supervised Learning with Pretext Tasks Self-supervised learning (SSL) typically employs a", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 600, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 505, + 613 + ], + "score": 1.0, + "content": "pretext task to generate pseudo-labels for unlabeled data via some forms of data transformation. Ac-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 611, + 505, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 505, + 624 + ], + "score": 1.0, + "content": "cording to the transformations used by the pretext task, existing SSL methods for video presentation", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 622, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 505, + 635 + ], + "score": 1.0, + "content": "learning can be divided into three categories: (1) Spatial-Only Transformations: Derived from the", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 633, + 505, + 646 + ], + "spans": [ + { + "bbox": [ + 106, + 633, + 505, + 646 + ], + "score": 1.0, + "content": "original image domain (Gidaris et al., 2018), Jing et al. (2018) leveraged the spatial-only transforma-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 643, + 506, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 643, + 506, + 658 + ], + "score": 1.0, + "content": "tions for self-supervised video presentation learning. (2) Temporal-Only Transformations: Misra", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 655, + 505, + 666 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 666 + ], + "score": 1.0, + "content": "et al. (2016); Fernando et al. (2017); Lee et al. (2017); Wei et al. (2018) obtained shuffled video", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 666, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 506, + 678 + ], + "score": 1.0, + "content": "frames with the temporal-only transformations and then distinguished whether the shuffled frames", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "are in chronological order. Xu et al. (2019) chose to shuffle video clips instead of frames. Benaim", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "et al. (2020); Yao et al. (2020); Jenni et al. (2020) exploited the speed transformation via determin-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "ing whether one video clip is accelerated. (3) Spatiotemporal Transformations: There are only a", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "few recent approaches (Ahsan et al., 2019; Kim et al., 2019) that leveraged both spatial and tempo-", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 720, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 734 + ], + "score": 1.0, + "content": "ral transformations by permuting 3D spatiotemporal cuboids. However, due to the aforementioned", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 82, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 506, + 96 + ], + "score": 1.0, + "content": "intractability of solving the spatiotemporal jigsaw puzzles, they only leveraged either temporal or", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "spatial permutations as training signals, i.e., they exploited the two domains independently. There-", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "fore, no true spatiotemporal permutations have been considered in Ahsan et al. (2019); Kim et al.", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 506, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 506, + 128 + ], + "score": 1.0, + "content": "(2019). In contrast, given that both spatial appearances and temporal relations are important cues", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 505, + 140 + ], + "score": 1.0, + "content": "for video representation learning, the focus of this work is on investigating how to exploit the spa-", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 136, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 136, + 505, + 150 + ], + "score": 1.0, + "content": "tial and temporal continuity jointly for self-supervised video presentation learning. To that end, our", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 147, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 147, + 505, + 161 + ], + "score": 1.0, + "content": "Constrained Spatiotemporal Jigsaw (CSJ) presents the first spatiotemporal continuity based pretext", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 505, + 172 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 505, + 172 + ], + "score": 1.0, + "content": "task for video SSL, thanks to a novel constrained 3D jigsaw and four surrogate tasks to reason about", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 170, + 386, + 183 + ], + "spans": [ + { + "bbox": [ + 105, + 170, + 386, + 183 + ], + "score": 1.0, + "content": "the continuity in the 3D jigsaw puzzles without solving them directly.", + "type": "text", + "cross_page": true + } + ], + "index": 8 + } + ], + "index": 42, + "bbox_fs": [ + 105, + 588, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 182 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 506, + 96 + ], + "score": 1.0, + "content": "intractability of solving the spatiotemporal jigsaw puzzles, they only leveraged either temporal or", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "spatial permutations as training signals, i.e., they exploited the two domains independently. There-", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "fore, no true spatiotemporal permutations have been considered in Ahsan et al. (2019); Kim et al.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 506, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 506, + 128 + ], + "score": 1.0, + "content": "(2019). In contrast, given that both spatial appearances and temporal relations are important cues", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 505, + 140 + ], + "score": 1.0, + "content": "for video representation learning, the focus of this work is on investigating how to exploit the spa-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 136, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 136, + 505, + 150 + ], + "score": 1.0, + "content": "tial and temporal continuity jointly for self-supervised video presentation learning. To that end, our", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 147, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 147, + 505, + 161 + ], + "score": 1.0, + "content": "Constrained Spatiotemporal Jigsaw (CSJ) presents the first spatiotemporal continuity based pretext", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 505, + 172 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 505, + 172 + ], + "score": 1.0, + "content": "task for video SSL, thanks to a novel constrained 3D jigsaw and four surrogate tasks to reason about", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 170, + 386, + 183 + ], + "spans": [ + { + "bbox": [ + 105, + 170, + 386, + 183 + ], + "score": 1.0, + "content": "the continuity in the 3D jigsaw puzzles without solving them directly.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 106, + 187, + 505, + 340 + ], + "lines": [ + { + "bbox": [ + 106, + 186, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 106, + 186, + 505, + 199 + ], + "score": 1.0, + "content": "Self-supervised Learning with Contrastive Learning Contrastive learning is another self-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 198, + 505, + 211 + ], + "spans": [ + { + "bbox": [ + 106, + 198, + 505, + 211 + ], + "score": 1.0, + "content": "supervised learning approach that has become increasingly popular in the image domain (Misra", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 208, + 506, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 208, + 506, + 222 + ], + "score": 1.0, + "content": "& Maaten, 2020; He et al., 2020; Chen et al., 2020). Recently, it has been incorporated into video", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 219, + 506, + 233 + ], + "spans": [ + { + "bbox": [ + 105, + 219, + 506, + 233 + ], + "score": 1.0, + "content": "SSL as well. Contrastive learning and transformation based pretext tasks are orthogonal to each", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 231, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 106, + 231, + 505, + 243 + ], + "score": 1.0, + "content": "other and often combined in that different transformed versions of a data sample form the positive", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 242, + 505, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 505, + 255 + ], + "score": 1.0, + "content": "set used in contrastive learning. In El-Nouby et al. (2019); Knights et al. (2020); Qian et al. (2020);", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 253, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 253, + 505, + 266 + ], + "score": 1.0, + "content": "Wang et al. (2020); Yang et al. (2020), the positive/negative samples were generated based on tem-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 263, + 505, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 505, + 277 + ], + "score": 1.0, + "content": "poral transformations only. In contrast, some recent works (Han et al., 2019; 2020; Zhuang et al.,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 274, + 505, + 287 + ], + "spans": [ + { + "bbox": [ + 105, + 274, + 505, + 287 + ], + "score": 1.0, + "content": "2020) leveraged features from the future frame embeddings or with the memory bank (Wu et al.,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 285, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 506, + 299 + ], + "score": 1.0, + "content": "2018). They modeled spatiotemporal representations using only contrastive learning without trans-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 296, + 506, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 506, + 309 + ], + "score": 1.0, + "content": "formations. Contrastive learning is also exploited in one of our surrogate pretext tasks. Different", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 308, + 504, + 320 + ], + "spans": [ + { + "bbox": [ + 106, + 308, + 504, + 320 + ], + "score": 1.0, + "content": "from existing works, we explore the spatiotemporal transformations in the form of CSJ and employ", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 318, + 504, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 318, + 504, + 331 + ], + "score": 1.0, + "content": "contrastive learning to distinguish different levels of spatiotemporal continuity in shuffled jigsaws.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 329, + 412, + 342 + ], + "spans": [ + { + "bbox": [ + 106, + 329, + 412, + 342 + ], + "score": 1.0, + "content": "This enables us to learn more discriminative spatiotemporal representations.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 15.5 + }, + { + "type": "title", + "bbox": [ + 108, + 356, + 338, + 369 + ], + "lines": [ + { + "bbox": [ + 105, + 355, + 340, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 355, + 340, + 371 + ], + "score": 1.0, + "content": "3 CONSTRAINED SPATIOTEMPORAL JIGSAW", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "title", + "bbox": [ + 108, + 380, + 227, + 392 + ], + "lines": [ + { + "bbox": [ + 105, + 380, + 228, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 228, + 393 + ], + "score": 1.0, + "content": "3.1 PROBLEM DEFINITION", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 107, + 401, + 504, + 456 + ], + "lines": [ + { + "bbox": [ + 105, + 400, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 400, + 505, + 414 + ], + "score": 1.0, + "content": "The main goal of self-supervised video representation learning is to learn a video feature represen-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 411, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 169, + 424 + ], + "score": 1.0, + "content": "tation function", + "type": "text" + }, + { + "bbox": [ + 169, + 412, + 187, + 424 + ], + "score": 0.91, + "content": "f ( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 411, + 505, + 424 + ], + "score": 1.0, + "content": "without using any human annotations. A general approach to achieving this", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 423, + 506, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 269, + 436 + ], + "score": 1.0, + "content": "goal is to generate a supervisory signal", + "type": "text" + }, + { + "bbox": [ + 269, + 425, + 277, + 434 + ], + "score": 0.78, + "content": "\\textbf { { y } }", + "type": "inline_equation" + }, + { + "bbox": [ + 277, + 423, + 400, + 436 + ], + "score": 1.0, + "content": "from an unlabeled video clip", + "type": "text" + }, + { + "bbox": [ + 400, + 425, + 408, + 433 + ], + "score": 0.78, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 423, + 506, + 436 + ], + "score": 1.0, + "content": "and construct a pretext", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 433, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 125, + 447 + ], + "score": 1.0, + "content": "task", + "type": "text" + }, + { + "bbox": [ + 126, + 434, + 135, + 444 + ], + "score": 0.83, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 135, + 433, + 177, + 447 + ], + "score": 1.0, + "content": "to predict", + "type": "text" + }, + { + "bbox": [ + 177, + 435, + 185, + 445 + ], + "score": 0.8, + "content": "\\textbf { { y } }", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 433, + 208, + 447 + ], + "score": 1.0, + "content": "from", + "type": "text" + }, + { + "bbox": [ + 209, + 434, + 230, + 446 + ], + "score": 0.92, + "content": "f ( { \\pmb x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 433, + 394, + 447 + ], + "score": 1.0, + "content": ". The process of solving the pretext task", + "type": "text" + }, + { + "bbox": [ + 394, + 434, + 403, + 444 + ], + "score": 0.83, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 404, + 433, + 452, + 447 + ], + "score": 1.0, + "content": "encourages", + "type": "text" + }, + { + "bbox": [ + 453, + 434, + 470, + 446 + ], + "score": 0.91, + "content": "f ( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 433, + 506, + 447 + ], + "score": 1.0, + "content": "to learn", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 445, + 293, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 293, + 457 + ], + "score": 1.0, + "content": "discriminative spatiotemporal representations.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 461, + 505, + 549 + ], + "lines": [ + { + "bbox": [ + 105, + 461, + 506, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 176, + 474 + ], + "score": 1.0, + "content": "The pretext task", + "type": "text" + }, + { + "bbox": [ + 176, + 462, + 185, + 471 + ], + "score": 0.81, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 461, + 506, + 474 + ], + "score": 1.0, + "content": "is constructed typically by applying to a video clip a transformation function", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 107, + 472, + 506, + 486 + ], + "spans": [ + { + "bbox": [ + 107, + 473, + 132, + 484 + ], + "score": 0.92, + "content": "t ( \\cdot ; \\pmb \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 472, + 205, + 486 + ], + "score": 1.0, + "content": "parameterized by", + "type": "text" + }, + { + "bbox": [ + 206, + 473, + 213, + 483 + ], + "score": 0.73, + "content": "\\pmb { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 472, + 344, + 486 + ], + "score": 1.0, + "content": "and then automatically deriving", + "type": "text" + }, + { + "bbox": [ + 344, + 475, + 352, + 484 + ], + "score": 0.76, + "content": "\\textbf { { y } }", + "type": "inline_equation" + }, + { + "bbox": [ + 353, + 472, + 375, + 486 + ], + "score": 1.0, + "content": "from", + "type": "text" + }, + { + "bbox": [ + 376, + 473, + 383, + 483 + ], + "score": 0.72, + "content": "\\pmb \\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 472, + 406, + 486 + ], + "score": 1.0, + "content": ", e.g.,", + "type": "text" + }, + { + "bbox": [ + 406, + 475, + 414, + 484 + ], + "score": 0.72, + "content": "\\textbf { { y } }", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 472, + 506, + 486 + ], + "score": 1.0, + "content": "can be the type of the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 483, + 506, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 268, + 497 + ], + "score": 1.0, + "content": "transformation. Based on this premise,", + "type": "text" + }, + { + "bbox": [ + 269, + 484, + 278, + 493 + ], + "score": 0.83, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 483, + 405, + 497 + ], + "score": 1.0, + "content": "is defined as the prediction of", + "type": "text" + }, + { + "bbox": [ + 405, + 486, + 412, + 495 + ], + "score": 0.81, + "content": "\\textbf { { y } }", + "type": "inline_equation" + }, + { + "bbox": [ + 413, + 483, + 506, + 497 + ], + "score": 1.0, + "content": "using the feature map", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 495, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 227, + 507 + ], + "score": 1.0, + "content": "of the transformed video clip", + "type": "text" + }, + { + "bbox": [ + 227, + 495, + 248, + 507 + ], + "score": 0.92, + "content": "f ( \\widetilde { \\pmb x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 495, + 270, + 507 + ], + "score": 1.0, + "content": ", i.e.,", + "type": "text" + }, + { + "bbox": [ + 271, + 495, + 333, + 507 + ], + "score": 0.94, + "content": "P : f ( { \\widetilde { \\mathbf { x } } } ) \\to { \\pmb y }", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 495, + 365, + 507 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 365, + 495, + 415, + 506 + ], + "score": 0.93, + "content": "\\widetilde { \\pmb { x } } = t ( \\pmb { x } ; \\pmb { \\theta } )", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 495, + 505, + 507 + ], + "score": 1.0, + "content": ". For example, in Lee", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 505, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 104, + 505, + 161, + 519 + ], + "score": 1.0, + "content": "et al. (2017),", + "type": "text" + }, + { + "bbox": [ + 161, + 506, + 187, + 517 + ], + "score": 0.92, + "content": "t ( \\cdot ; \\pmb \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 505, + 506, + 519 + ], + "score": 1.0, + "content": "e e e denotes a temporal transformation that permutes the four frames of video clip", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 107, + 516, + 506, + 529 + ], + "spans": [ + { + "bbox": [ + 107, + 519, + 114, + 527 + ], + "score": 0.71, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 115, + 516, + 196, + 529 + ], + "score": 1.0, + "content": "in a temporal order", + "type": "text" + }, + { + "bbox": [ + 197, + 517, + 204, + 527 + ], + "score": 0.52, + "content": "\\pmb \\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 204, + 516, + 208, + 529 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 208, + 516, + 259, + 528 + ], + "score": 0.92, + "content": "\\widetilde { \\pmb { x } } = t ( \\pmb { x } ; \\pmb { \\theta } )", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 516, + 427, + 529 + ], + "score": 1.0, + "content": "is the shuffled clip, and the pseudo-label", + "type": "text" + }, + { + "bbox": [ + 428, + 518, + 435, + 528 + ], + "score": 0.78, + "content": "\\textbf { { y } }", + "type": "inline_equation" + }, + { + "bbox": [ + 436, + 516, + 506, + 529 + ], + "score": 1.0, + "content": "is defined as the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 527, + 506, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 181, + 540 + ], + "score": 1.0, + "content": "permutation order", + "type": "text" + }, + { + "bbox": [ + 181, + 528, + 189, + 537 + ], + "score": 0.66, + "content": "\\pmb \\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 527, + 356, + 540 + ], + "score": 1.0, + "content": "e(e.g., 1324, 4312, etc.). The pretext task", + "type": "text" + }, + { + "bbox": [ + 356, + 528, + 365, + 537 + ], + "score": 0.84, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 527, + 506, + 540 + ], + "score": 1.0, + "content": "is then a classification problem of", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 538, + 331, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 232, + 550 + ], + "score": 1.0, + "content": "24 categories because there are", + "type": "text" + }, + { + "bbox": [ + 233, + 539, + 265, + 549 + ], + "score": 0.88, + "content": "4 ! = 2 4", + "type": "inline_equation" + }, + { + "bbox": [ + 266, + 538, + 331, + 550 + ], + "score": 1.0, + "content": "possible orders.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 33.5 + }, + { + "type": "title", + "bbox": [ + 108, + 562, + 264, + 573 + ], + "lines": [ + { + "bbox": [ + 105, + 561, + 266, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 266, + 575 + ], + "score": 1.0, + "content": "3.2 CONSTRAINED PERMUTATIONS", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 107, + 582, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 583, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 505, + 596 + ], + "score": 1.0, + "content": "Solving spatiotemporal video jigsaw puzzles seems to be an ideal pretext task for learning discrimi-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "native representation as it requires an understanding of spatiotemporal continuity. After shuffling the", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 605, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 505, + 618 + ], + "score": 1.0, + "content": "pixels in a video clip using a 3D permutation matrix, the pretext task is to recover the permutation", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 615, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 629 + ], + "score": 1.0, + "content": "matrix. However, as explained earlier, this task is intractable given even moderate video clip sizes.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 625, + 504, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 625, + 484, + 640 + ], + "score": 1.0, + "content": "Our solution is to introduce constraints on the permutations. As a result, a new pretext task", + "type": "text" + }, + { + "bbox": [ + 484, + 627, + 504, + 638 + ], + "score": 0.88, + "content": "P _ { \\mathrm { C S J } }", + "type": "inline_equation" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 638, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 506, + 651 + ], + "score": 1.0, + "content": "based on Constrained Spatiotemporal Jigsaw (see Fig. 2(a)) is formulated, which is much easier", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 648, + 289, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 289, + 662 + ], + "score": 1.0, + "content": "to solve than a random/unconstrained jigsaw.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 733 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 506, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 677 + ], + "score": 1.0, + "content": "Specifically, our goal is to introduce constraints to the permutations so that the resultant shuffled", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "score": 1.0, + "content": "video clip is guaranteed to have large continuous cuboids (see Fig. 2(a)). Similar to humans (Stringer", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 687, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 699 + ], + "score": 1.0, + "content": "et al., 2006), having large continuous cuboids is key for a model to understand a 3D jigsaw and", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 447, + 711 + ], + "score": 1.0, + "content": "therefore to have any chance to solve it. Formally, the volume of a shuffled video clip", + "type": "text" + }, + { + "bbox": [ + 447, + 699, + 455, + 709 + ], + "score": 0.82, + "content": "\\widetilde { \\pmb x }", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "are denoted", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 118, + 723 + ], + "score": 1.0, + "content": "as", + "type": "text" + }, + { + "bbox": [ + 118, + 709, + 163, + 722 + ], + "score": 0.93, + "content": "\\{ T , H , W \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "e, measuring its sizes along the temporal, height, and width dimensions, respectively.", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 104, + 718, + 505, + 735 + ], + "spans": [ + { + "bbox": [ + 104, + 718, + 239, + 735 + ], + "score": 1.0, + "content": "A cuboid is defined as a crop of", + "type": "text" + }, + { + "bbox": [ + 240, + 721, + 247, + 730 + ], + "score": 0.77, + "content": "\\widetilde { \\pmb x }", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 718, + 252, + 735 + ], + "score": 1.0, + "content": ":", + "type": "text" + }, + { + "bbox": [ + 253, + 721, + 342, + 733 + ], + "score": 0.92, + "content": "\\pmb { c } = \\widetilde { \\pmb { x } } _ { t _ { 1 } : t _ { 2 } , h _ { 1 } : h _ { 2 } , w _ { 1 } : w _ { 2 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 718, + 374, + 735 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 375, + 720, + 505, + 732 + ], + "score": 0.92, + "content": "t _ { 1 } , t _ { 2 } \\in \\{ 1 , 2 , \\dots , T \\} , h _ { 1 } , h _ { 2 } \\in", + "type": "inline_equation" + } + ], + "index": 51 + } + ], + "index": 48.5 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 306, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 303, + 751, + 309, + 759 + ], + "lines": [] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 182 + ], + "lines": [], + "index": 4, + "bbox_fs": [ + 105, + 82, + 506, + 183 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 187, + 505, + 340 + ], + "lines": [ + { + "bbox": [ + 106, + 186, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 106, + 186, + 505, + 199 + ], + "score": 1.0, + "content": "Self-supervised Learning with Contrastive Learning Contrastive learning is another self-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 198, + 505, + 211 + ], + "spans": [ + { + "bbox": [ + 106, + 198, + 505, + 211 + ], + "score": 1.0, + "content": "supervised learning approach that has become increasingly popular in the image domain (Misra", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 208, + 506, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 208, + 506, + 222 + ], + "score": 1.0, + "content": "& Maaten, 2020; He et al., 2020; Chen et al., 2020). Recently, it has been incorporated into video", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 219, + 506, + 233 + ], + "spans": [ + { + "bbox": [ + 105, + 219, + 506, + 233 + ], + "score": 1.0, + "content": "SSL as well. Contrastive learning and transformation based pretext tasks are orthogonal to each", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 231, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 106, + 231, + 505, + 243 + ], + "score": 1.0, + "content": "other and often combined in that different transformed versions of a data sample form the positive", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 242, + 505, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 505, + 255 + ], + "score": 1.0, + "content": "set used in contrastive learning. In El-Nouby et al. (2019); Knights et al. (2020); Qian et al. (2020);", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 253, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 253, + 505, + 266 + ], + "score": 1.0, + "content": "Wang et al. (2020); Yang et al. (2020), the positive/negative samples were generated based on tem-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 263, + 505, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 505, + 277 + ], + "score": 1.0, + "content": "poral transformations only. In contrast, some recent works (Han et al., 2019; 2020; Zhuang et al.,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 274, + 505, + 287 + ], + "spans": [ + { + "bbox": [ + 105, + 274, + 505, + 287 + ], + "score": 1.0, + "content": "2020) leveraged features from the future frame embeddings or with the memory bank (Wu et al.,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 285, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 506, + 299 + ], + "score": 1.0, + "content": "2018). They modeled spatiotemporal representations using only contrastive learning without trans-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 296, + 506, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 506, + 309 + ], + "score": 1.0, + "content": "formations. Contrastive learning is also exploited in one of our surrogate pretext tasks. Different", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 308, + 504, + 320 + ], + "spans": [ + { + "bbox": [ + 106, + 308, + 504, + 320 + ], + "score": 1.0, + "content": "from existing works, we explore the spatiotemporal transformations in the form of CSJ and employ", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 318, + 504, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 318, + 504, + 331 + ], + "score": 1.0, + "content": "contrastive learning to distinguish different levels of spatiotemporal continuity in shuffled jigsaws.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 329, + 412, + 342 + ], + "spans": [ + { + "bbox": [ + 106, + 329, + 412, + 342 + ], + "score": 1.0, + "content": "This enables us to learn more discriminative spatiotemporal representations.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 186, + 506, + 342 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 356, + 338, + 369 + ], + "lines": [ + { + "bbox": [ + 105, + 355, + 340, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 355, + 340, + 371 + ], + "score": 1.0, + "content": "3 CONSTRAINED SPATIOTEMPORAL JIGSAW", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "title", + "bbox": [ + 108, + 380, + 227, + 392 + ], + "lines": [ + { + "bbox": [ + 105, + 380, + 228, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 228, + 393 + ], + "score": 1.0, + "content": "3.1 PROBLEM DEFINITION", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 107, + 401, + 504, + 456 + ], + "lines": [ + { + "bbox": [ + 105, + 400, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 400, + 505, + 414 + ], + "score": 1.0, + "content": "The main goal of self-supervised video representation learning is to learn a video feature represen-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 411, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 169, + 424 + ], + "score": 1.0, + "content": "tation function", + "type": "text" + }, + { + "bbox": [ + 169, + 412, + 187, + 424 + ], + "score": 0.91, + "content": "f ( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 411, + 505, + 424 + ], + "score": 1.0, + "content": "without using any human annotations. A general approach to achieving this", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 423, + 506, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 269, + 436 + ], + "score": 1.0, + "content": "goal is to generate a supervisory signal", + "type": "text" + }, + { + "bbox": [ + 269, + 425, + 277, + 434 + ], + "score": 0.78, + "content": "\\textbf { { y } }", + "type": "inline_equation" + }, + { + "bbox": [ + 277, + 423, + 400, + 436 + ], + "score": 1.0, + "content": "from an unlabeled video clip", + "type": "text" + }, + { + "bbox": [ + 400, + 425, + 408, + 433 + ], + "score": 0.78, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 423, + 506, + 436 + ], + "score": 1.0, + "content": "and construct a pretext", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 433, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 125, + 447 + ], + "score": 1.0, + "content": "task", + "type": "text" + }, + { + "bbox": [ + 126, + 434, + 135, + 444 + ], + "score": 0.83, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 135, + 433, + 177, + 447 + ], + "score": 1.0, + "content": "to predict", + "type": "text" + }, + { + "bbox": [ + 177, + 435, + 185, + 445 + ], + "score": 0.8, + "content": "\\textbf { { y } }", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 433, + 208, + 447 + ], + "score": 1.0, + "content": "from", + "type": "text" + }, + { + "bbox": [ + 209, + 434, + 230, + 446 + ], + "score": 0.92, + "content": "f ( { \\pmb x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 433, + 394, + 447 + ], + "score": 1.0, + "content": ". The process of solving the pretext task", + "type": "text" + }, + { + "bbox": [ + 394, + 434, + 403, + 444 + ], + "score": 0.83, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 404, + 433, + 452, + 447 + ], + "score": 1.0, + "content": "encourages", + "type": "text" + }, + { + "bbox": [ + 453, + 434, + 470, + 446 + ], + "score": 0.91, + "content": "f ( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 433, + 506, + 447 + ], + "score": 1.0, + "content": "to learn", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 445, + 293, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 293, + 457 + ], + "score": 1.0, + "content": "discriminative spatiotemporal representations.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 400, + 506, + 457 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 461, + 505, + 549 + ], + "lines": [ + { + "bbox": [ + 105, + 461, + 506, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 176, + 474 + ], + "score": 1.0, + "content": "The pretext task", + "type": "text" + }, + { + "bbox": [ + 176, + 462, + 185, + 471 + ], + "score": 0.81, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 461, + 506, + 474 + ], + "score": 1.0, + "content": "is constructed typically by applying to a video clip a transformation function", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 107, + 472, + 506, + 486 + ], + "spans": [ + { + "bbox": [ + 107, + 473, + 132, + 484 + ], + "score": 0.92, + "content": "t ( \\cdot ; \\pmb \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 472, + 205, + 486 + ], + "score": 1.0, + "content": "parameterized by", + "type": "text" + }, + { + "bbox": [ + 206, + 473, + 213, + 483 + ], + "score": 0.73, + "content": "\\pmb { \\theta }", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 472, + 344, + 486 + ], + "score": 1.0, + "content": "and then automatically deriving", + "type": "text" + }, + { + "bbox": [ + 344, + 475, + 352, + 484 + ], + "score": 0.76, + "content": "\\textbf { { y } }", + "type": "inline_equation" + }, + { + "bbox": [ + 353, + 472, + 375, + 486 + ], + "score": 1.0, + "content": "from", + "type": "text" + }, + { + "bbox": [ + 376, + 473, + 383, + 483 + ], + "score": 0.72, + "content": "\\pmb \\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 472, + 406, + 486 + ], + "score": 1.0, + "content": ", e.g.,", + "type": "text" + }, + { + "bbox": [ + 406, + 475, + 414, + 484 + ], + "score": 0.72, + "content": "\\textbf { { y } }", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 472, + 506, + 486 + ], + "score": 1.0, + "content": "can be the type of the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 483, + 506, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 268, + 497 + ], + "score": 1.0, + "content": "transformation. Based on this premise,", + "type": "text" + }, + { + "bbox": [ + 269, + 484, + 278, + 493 + ], + "score": 0.83, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 483, + 405, + 497 + ], + "score": 1.0, + "content": "is defined as the prediction of", + "type": "text" + }, + { + "bbox": [ + 405, + 486, + 412, + 495 + ], + "score": 0.81, + "content": "\\textbf { { y } }", + "type": "inline_equation" + }, + { + "bbox": [ + 413, + 483, + 506, + 497 + ], + "score": 1.0, + "content": "using the feature map", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 495, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 227, + 507 + ], + "score": 1.0, + "content": "of the transformed video clip", + "type": "text" + }, + { + "bbox": [ + 227, + 495, + 248, + 507 + ], + "score": 0.92, + "content": "f ( \\widetilde { \\pmb x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 495, + 270, + 507 + ], + "score": 1.0, + "content": ", i.e.,", + "type": "text" + }, + { + "bbox": [ + 271, + 495, + 333, + 507 + ], + "score": 0.94, + "content": "P : f ( { \\widetilde { \\mathbf { x } } } ) \\to { \\pmb y }", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 495, + 365, + 507 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 365, + 495, + 415, + 506 + ], + "score": 0.93, + "content": "\\widetilde { \\pmb { x } } = t ( \\pmb { x } ; \\pmb { \\theta } )", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 495, + 505, + 507 + ], + "score": 1.0, + "content": ". For example, in Lee", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 505, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 104, + 505, + 161, + 519 + ], + "score": 1.0, + "content": "et al. (2017),", + "type": "text" + }, + { + "bbox": [ + 161, + 506, + 187, + 517 + ], + "score": 0.92, + "content": "t ( \\cdot ; \\pmb \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 505, + 506, + 519 + ], + "score": 1.0, + "content": "e e e denotes a temporal transformation that permutes the four frames of video clip", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 107, + 516, + 506, + 529 + ], + "spans": [ + { + "bbox": [ + 107, + 519, + 114, + 527 + ], + "score": 0.71, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 115, + 516, + 196, + 529 + ], + "score": 1.0, + "content": "in a temporal order", + "type": "text" + }, + { + "bbox": [ + 197, + 517, + 204, + 527 + ], + "score": 0.52, + "content": "\\pmb \\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 204, + 516, + 208, + 529 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 208, + 516, + 259, + 528 + ], + "score": 0.92, + "content": "\\widetilde { \\pmb { x } } = t ( \\pmb { x } ; \\pmb { \\theta } )", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 516, + 427, + 529 + ], + "score": 1.0, + "content": "is the shuffled clip, and the pseudo-label", + "type": "text" + }, + { + "bbox": [ + 428, + 518, + 435, + 528 + ], + "score": 0.78, + "content": "\\textbf { { y } }", + "type": "inline_equation" + }, + { + "bbox": [ + 436, + 516, + 506, + 529 + ], + "score": 1.0, + "content": "is defined as the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 527, + 506, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 181, + 540 + ], + "score": 1.0, + "content": "permutation order", + "type": "text" + }, + { + "bbox": [ + 181, + 528, + 189, + 537 + ], + "score": 0.66, + "content": "\\pmb \\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 527, + 356, + 540 + ], + "score": 1.0, + "content": "e(e.g., 1324, 4312, etc.). The pretext task", + "type": "text" + }, + { + "bbox": [ + 356, + 528, + 365, + 537 + ], + "score": 0.84, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 527, + 506, + 540 + ], + "score": 1.0, + "content": "is then a classification problem of", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 538, + 331, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 232, + 550 + ], + "score": 1.0, + "content": "24 categories because there are", + "type": "text" + }, + { + "bbox": [ + 233, + 539, + 265, + 549 + ], + "score": 0.88, + "content": "4 ! = 2 4", + "type": "inline_equation" + }, + { + "bbox": [ + 266, + 538, + 331, + 550 + ], + "score": 1.0, + "content": "possible orders.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 33.5, + "bbox_fs": [ + 104, + 461, + 506, + 550 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 562, + 264, + 573 + ], + "lines": [ + { + "bbox": [ + 105, + 561, + 266, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 266, + 575 + ], + "score": 1.0, + "content": "3.2 CONSTRAINED PERMUTATIONS", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 107, + 582, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 583, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 505, + 596 + ], + "score": 1.0, + "content": "Solving spatiotemporal video jigsaw puzzles seems to be an ideal pretext task for learning discrimi-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "native representation as it requires an understanding of spatiotemporal continuity. After shuffling the", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 605, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 505, + 618 + ], + "score": 1.0, + "content": "pixels in a video clip using a 3D permutation matrix, the pretext task is to recover the permutation", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 615, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 629 + ], + "score": 1.0, + "content": "matrix. However, as explained earlier, this task is intractable given even moderate video clip sizes.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 625, + 504, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 625, + 484, + 640 + ], + "score": 1.0, + "content": "Our solution is to introduce constraints on the permutations. As a result, a new pretext task", + "type": "text" + }, + { + "bbox": [ + 484, + 627, + 504, + 638 + ], + "score": 0.88, + "content": "P _ { \\mathrm { C S J } }", + "type": "inline_equation" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 638, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 506, + 651 + ], + "score": 1.0, + "content": "based on Constrained Spatiotemporal Jigsaw (see Fig. 2(a)) is formulated, which is much easier", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 648, + 289, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 289, + 662 + ], + "score": 1.0, + "content": "to solve than a random/unconstrained jigsaw.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 42, + "bbox_fs": [ + 105, + 583, + 506, + 662 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 733 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 506, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 677 + ], + "score": 1.0, + "content": "Specifically, our goal is to introduce constraints to the permutations so that the resultant shuffled", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "score": 1.0, + "content": "video clip is guaranteed to have large continuous cuboids (see Fig. 2(a)). Similar to humans (Stringer", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 687, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 699 + ], + "score": 1.0, + "content": "et al., 2006), having large continuous cuboids is key for a model to understand a 3D jigsaw and", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 447, + 711 + ], + "score": 1.0, + "content": "therefore to have any chance to solve it. Formally, the volume of a shuffled video clip", + "type": "text" + }, + { + "bbox": [ + 447, + 699, + 455, + 709 + ], + "score": 0.82, + "content": "\\widetilde { \\pmb x }", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "are denoted", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 118, + 723 + ], + "score": 1.0, + "content": "as", + "type": "text" + }, + { + "bbox": [ + 118, + 709, + 163, + 722 + ], + "score": 0.93, + "content": "\\{ T , H , W \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "e, measuring its sizes along the temporal, height, and width dimensions, respectively.", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 104, + 718, + 505, + 735 + ], + "spans": [ + { + "bbox": [ + 104, + 718, + 239, + 735 + ], + "score": 1.0, + "content": "A cuboid is defined as a crop of", + "type": "text" + }, + { + "bbox": [ + 240, + 721, + 247, + 730 + ], + "score": 0.77, + "content": "\\widetilde { \\pmb x }", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 718, + 252, + 735 + ], + "score": 1.0, + "content": ":", + "type": "text" + }, + { + "bbox": [ + 253, + 721, + 342, + 733 + ], + "score": 0.92, + "content": "\\pmb { c } = \\widetilde { \\pmb { x } } _ { t _ { 1 } : t _ { 2 } , h _ { 1 } : h _ { 2 } , w _ { 1 } : w _ { 2 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 718, + 374, + 735 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 375, + 720, + 505, + 732 + ], + "score": 0.92, + "content": "t _ { 1 } , t _ { 2 } \\in \\{ 1 , 2 , \\dots , T \\} , h _ { 1 } , h _ { 2 } \\in", + "type": "inline_equation" + } + ], + "index": 51 + }, + { + "bbox": [ + 107, + 351, + 506, + 365 + ], + "spans": [ + { + "bbox": [ + 107, + 352, + 265, + 364 + ], + "score": 0.89, + "content": "\\{ 1 , 2 , \\ldots , H \\} , w _ { 1 } , w _ { 2 } \\in \\{ 1 , 2 , \\ldots , W \\}", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 265, + 351, + 506, + 365 + ], + "score": 1.0, + "content": ". If all the jigsaw pieces (smallest video clip unit, e.g. a pixel", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 363, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 200, + 375 + ], + "score": 1.0, + "content": "or a 3D pixel block) in", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 200, + 365, + 207, + 373 + ], + "score": 0.52, + "content": "^ c", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 207, + 363, + 385, + 375 + ], + "score": 1.0, + "content": "keep the same relative order as they were in", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 385, + 365, + 393, + 373 + ], + "score": 0.7, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 393, + 363, + 505, + 375 + ], + "score": 1.0, + "content": "(before being shuffled), we", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 104, + 371, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 104, + 371, + 167, + 387 + ], + "score": 1.0, + "content": "call the cuboid", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 168, + 376, + 174, + 384 + ], + "score": 0.67, + "content": "^ c", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 175, + 371, + 268, + 387 + ], + "score": 1.0, + "content": "as a continuous cuboid", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 268, + 374, + 287, + 384 + ], + "score": 0.87, + "content": "c ^ { \\mathrm { c o n t } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 287, + 371, + 406, + 387 + ], + "score": 1.0, + "content": ". The cuboid’s volume equals", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 406, + 374, + 505, + 386 + ], + "score": 0.92, + "content": "\\left( t _ { 2 } - t _ { 1 } \\right) \\mathbf { \\bar { \\times } } \\left( h _ { 2 } - h _ { 1 } \\right) \\times \\mathbf { \\bar { \\Sigma } }", + "type": "inline_equation", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 107, + 380, + 482, + 402 + ], + "spans": [ + { + "bbox": [ + 107, + 385, + 150, + 397 + ], + "score": 0.91, + "content": "( w _ { 2 } - w _ { 1 } )", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 151, + 380, + 319, + 402 + ], + "score": 1.0, + "content": ", and the largest continuous cuboid (LCC)", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 319, + 384, + 338, + 397 + ], + "score": 0.9, + "content": "c _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 339, + 380, + 363, + 402 + ], + "score": 1.0, + "content": "is the", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 363, + 385, + 382, + 395 + ], + "score": 0.88, + "content": "c ^ { \\mathrm { c o n t } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 383, + 380, + 482, + 402 + ], + "score": 1.0, + "content": "with the largest volume.", + "type": "text", + "cross_page": true + } + ], + "index": 11 + } + ], + "index": 48.5, + "bbox_fs": [ + 104, + 665, + 506, + 735 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 118, + 81, + 488, + 280 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 118, + 81, + 488, + 280 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 118, + 81, + 488, + 280 + ], + "spans": [ + { + "bbox": [ + 118, + 81, + 488, + 280 + ], + "score": 0.974, + "type": "image", + "image_path": "1078e24fffb3ba13c20ebafabd92aee164ef40d676a91283df6ddb5e42457aac.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 118, + 81, + 488, + 147.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 118, + 147.33333333333331, + 488, + 213.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 118, + 213.66666666666663, + 488, + 279.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 284, + 505, + 339 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 283, + 505, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 283, + 505, + 297 + ], + "score": 1.0, + "content": "Figure 2: (a) Illustration of our Constrained Spatiotemporal Jigsaw (CSJ) (see Sec. 3.2). (b) The", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 295, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 505, + 308 + ], + "score": 1.0, + "content": "pipeline of our proposed framework for self-supervised video representation learning (see Sec. 3.3).", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 104, + 304, + 505, + 321 + ], + "spans": [ + { + "bbox": [ + 104, + 304, + 505, + 321 + ], + "score": 1.0, + "content": "A raw video clip is transformed into 8 shuffled clips with our Constrained Spatiotemporal Jig-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 316, + 506, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 316, + 506, + 331 + ], + "score": 1.0, + "content": "saw (CSJ), and a 3D CNN sharing weights extracts the feature representations from them. The", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 327, + 372, + 341 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 372, + 341 + ], + "score": 1.0, + "content": "model is then trained by solving four self-supervised tasks jointly.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5 + } + ], + "index": 3.0 + }, + { + "type": "text", + "bbox": [ + 107, + 352, + 505, + 397 + ], + "lines": [ + { + "bbox": [ + 107, + 351, + 506, + 365 + ], + "spans": [ + { + "bbox": [ + 107, + 352, + 265, + 364 + ], + "score": 0.89, + "content": "\\{ 1 , 2 , \\ldots , H \\} , w _ { 1 } , w _ { 2 } \\in \\{ 1 , 2 , \\ldots , W \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 351, + 506, + 365 + ], + "score": 1.0, + "content": ". If all the jigsaw pieces (smallest video clip unit, e.g. a pixel", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 363, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 200, + 375 + ], + "score": 1.0, + "content": "or a 3D pixel block) in", + "type": "text" + }, + { + "bbox": [ + 200, + 365, + 207, + 373 + ], + "score": 0.52, + "content": "^ c", + "type": "inline_equation" + }, + { + "bbox": [ + 207, + 363, + 385, + 375 + ], + "score": 1.0, + "content": "keep the same relative order as they were in", + "type": "text" + }, + { + "bbox": [ + 385, + 365, + 393, + 373 + ], + "score": 0.7, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 363, + 505, + 375 + ], + "score": 1.0, + "content": "(before being shuffled), we", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 104, + 371, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 104, + 371, + 167, + 387 + ], + "score": 1.0, + "content": "call the cuboid", + "type": "text" + }, + { + "bbox": [ + 168, + 376, + 174, + 384 + ], + "score": 0.67, + "content": "^ c", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 371, + 268, + 387 + ], + "score": 1.0, + "content": "as a continuous cuboid", + "type": "text" + }, + { + "bbox": [ + 268, + 374, + 287, + 384 + ], + "score": 0.87, + "content": "c ^ { \\mathrm { c o n t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 287, + 371, + 406, + 387 + ], + "score": 1.0, + "content": ". The cuboid’s volume equals", + "type": "text" + }, + { + "bbox": [ + 406, + 374, + 505, + 386 + ], + "score": 0.92, + "content": "\\left( t _ { 2 } - t _ { 1 } \\right) \\mathbf { \\bar { \\times } } \\left( h _ { 2 } - h _ { 1 } \\right) \\times \\mathbf { \\bar { \\Sigma } }", + "type": "inline_equation" + } + ], + "index": 10 + }, + { + "bbox": [ + 107, + 380, + 482, + 402 + ], + "spans": [ + { + "bbox": [ + 107, + 385, + 150, + 397 + ], + "score": 0.91, + "content": "( w _ { 2 } - w _ { 1 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 380, + 319, + 402 + ], + "score": 1.0, + "content": ", and the largest continuous cuboid (LCC)", + "type": "text" + }, + { + "bbox": [ + 319, + 384, + 338, + 397 + ], + "score": 0.9, + "content": "c _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 380, + 363, + 402 + ], + "score": 1.0, + "content": "is the", + "type": "text" + }, + { + "bbox": [ + 363, + 385, + 382, + 395 + ], + "score": 0.88, + "content": "c ^ { \\mathrm { c o n t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 380, + 482, + 402 + ], + "score": 1.0, + "content": "with the largest volume.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 106, + 402, + 505, + 545 + ], + "lines": [ + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "score": 1.0, + "content": "We introduce two permutation strategies to ensure that the volumes of LCCs are large in relation to", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 411, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 360, + 426 + ], + "score": 1.0, + "content": "the whole video clip volume after our shuffling transformation", + "type": "text" + }, + { + "bbox": [ + 360, + 412, + 396, + 424 + ], + "score": 0.92, + "content": "t ( \\cdot ; \\theta _ { \\mathrm { C S J } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 411, + 506, + 426 + ], + "score": 1.0, + "content": ". First, instead of shuffling", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 424, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 106, + 425, + 114, + 434 + ], + "score": 0.73, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 115, + 424, + 323, + 437 + ], + "score": 1.0, + "content": "in three spatiotemporal dimensions simultaneously,", + "type": "text" + }, + { + "bbox": [ + 323, + 424, + 360, + 436 + ], + "score": 0.92, + "content": "t ( \\cdot ; \\theta _ { \\mathrm { C S J } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 424, + 505, + 437 + ], + "score": 1.0, + "content": "factorizes the permutations into the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 433, + 506, + 449 + ], + "spans": [ + { + "bbox": [ + 104, + 433, + 506, + 449 + ], + "score": 1.0, + "content": "three spatiotemporal dimensions and then utilizes them sequentially to generate shuffled clips, e.g.,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 446, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 169, + 459 + ], + "score": 1.0, + "content": "in the order of", + "type": "text" + }, + { + "bbox": [ + 169, + 446, + 205, + 457 + ], + "score": 0.91, + "content": "T , W , H", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 446, + 433, + 459 + ], + "score": 1.0, + "content": "and only once. Note that the volume of the generated", + "type": "text" + }, + { + "bbox": [ + 433, + 446, + 441, + 456 + ], + "score": 0.81, + "content": "\\widetilde { \\pmb x }", + "type": "inline_equation" + }, + { + "bbox": [ + 442, + 446, + 506, + 459 + ], + "score": 1.0, + "content": "stays the same", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 456, + 505, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 266, + 470 + ], + "score": 1.0, + "content": "with different permutation orders (e.g.,", + "type": "text" + }, + { + "bbox": [ + 267, + 457, + 295, + 467 + ], + "score": 0.33, + "content": "T W H", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 456, + 314, + 470 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 314, + 457, + 343, + 467 + ], + "score": 0.29, + "content": "H T W", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 456, + 505, + 470 + ], + "score": 1.0, + "content": "e). Second, we shuffle a group of jigsaw", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 466, + 506, + 481 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 506, + 481 + ], + "score": 1.0, + "content": "pieces together instead of each piece individually along each dimension. Taking spatial shuffling as", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 479, + 506, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 479, + 460, + 491 + ], + "score": 1.0, + "content": "an example, if there are 8 pieces per frame (along each of the two spatial dimensions),", + "type": "text" + }, + { + "bbox": [ + 460, + 479, + 479, + 490 + ], + "score": 0.89, + "content": "\\theta _ { \\mathrm { C S J } }", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 479, + 506, + 491 + ], + "score": 1.0, + "content": "could", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 489, + 506, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 268, + 502 + ], + "score": 1.0, + "content": "be represented as the permutation from", + "type": "text" + }, + { + "bbox": [ + 268, + 489, + 319, + 501 + ], + "score": 0.92, + "content": "\\{ 1 2 3 4 5 6 7 8 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 319, + 489, + 332, + 502 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 332, + 489, + 382, + 501 + ], + "score": 0.86, + "content": "\\{ 8 4 5 6 7 1 2 3 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 489, + 506, + 502 + ], + "score": 1.0, + "content": ". The longest and the second-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 104, + 500, + 506, + 514 + ], + "spans": [ + { + "bbox": [ + 104, + 500, + 304, + 514 + ], + "score": 1.0, + "content": "longest index ranges are: [2, 5] for coordinates", + "type": "text" + }, + { + "bbox": [ + 305, + 501, + 335, + 512 + ], + "score": 0.92, + "content": "\\{ 4 5 6 7 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 500, + 448, + 514 + ], + "score": 1.0, + "content": ", and [6, 8] for coordinates", + "type": "text" + }, + { + "bbox": [ + 449, + 500, + 474, + 513 + ], + "score": 0.86, + "content": "\\lbrace 1 2 3 \\rbrace", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 500, + 506, + 514 + ], + "score": 1.0, + "content": ". With", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 511, + 506, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 506, + 524 + ], + "score": 1.0, + "content": "these two permutation strategies, not only do we have large LCCs, but also they are guaranteed to", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 523, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 505, + 534 + ], + "score": 1.0, + "content": "have clearly separable boundaries (see Fig. 2(b)) with surrounding pieces due to the factorized and", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 533, + 394, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 394, + 547 + ], + "score": 1.0, + "content": "grouped permutation design. This means that they are easily detectable.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 18 + }, + { + "type": "title", + "bbox": [ + 108, + 555, + 214, + 567 + ], + "lines": [ + { + "bbox": [ + 105, + 554, + 216, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 216, + 568 + ], + "score": 1.0, + "content": "3.3 SURROGATE TASKS", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 576, + 505, + 675 + ], + "lines": [ + { + "bbox": [ + 106, + 576, + 505, + 589 + ], + "spans": [ + { + "bbox": [ + 106, + 576, + 505, + 589 + ], + "score": 1.0, + "content": "Having permutation constraints preserves more spatiotemporal continuity in the shuffled clip and re-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 586, + 506, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 506, + 600 + ], + "score": 1.0, + "content": "duces the amount of possible permutations. But exploiting these constraints to make a neural sorting", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 597, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 426, + 611 + ], + "score": 1.0, + "content": "model tractable is still far from trivial. Instead of solving the jigsaw directly, our", + "type": "text" + }, + { + "bbox": [ + 427, + 598, + 446, + 609 + ], + "score": 0.9, + "content": "P _ { \\mathrm { C S J } }", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 597, + 505, + 611 + ], + "score": 1.0, + "content": "is thus formu-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 608, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 608, + 505, + 622 + ], + "score": 1.0, + "content": "lated as four surrogate tasks: Largest Continuous Cuboid Detection (LCCD), Clip Shuffling Pattern", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 618, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 505, + 633 + ], + "score": 1.0, + "content": "Classification (CSPC), Contrastive Learning over Shuffled Clips (CLSC), and Clip Continuity Mea-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 630, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 415, + 643 + ], + "score": 1.0, + "content": "sure Regression (CCMR). As illustrated in Fig. 2(b), given an unlabeled clip", + "type": "text" + }, + { + "bbox": [ + 415, + 633, + 423, + 641 + ], + "score": 0.72, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 630, + 505, + 643 + ], + "score": 1.0, + "content": ", we first construct a", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 640, + 505, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 191, + 655 + ], + "score": 1.0, + "content": "mini-batch of 8 clips", + "type": "text" + }, + { + "bbox": [ + 192, + 641, + 257, + 654 + ], + "score": 0.92, + "content": "\\{ \\widetilde { \\pmb { x } } _ { 1 } , \\widetilde { \\pmb { x } } _ { 2 } , . . . , \\widetilde { \\pmb { x } } _ { 8 } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 640, + 308, + 655 + ], + "score": 1.0, + "content": "by shuffling", + "type": "text" + }, + { + "bbox": [ + 308, + 644, + 316, + 652 + ], + "score": 0.77, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 640, + 505, + 655 + ], + "score": 1.0, + "content": "with different but related constrained permuta-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 652, + 505, + 665 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 358, + 665 + ], + "score": 1.0, + "content": "e e etions (to be detailed later). These shuffled clips and the raw clip", + "type": "text" + }, + { + "bbox": [ + 359, + 654, + 367, + 663 + ], + "score": 0.76, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 652, + 505, + 665 + ], + "score": 1.0, + "content": "are then fed into a 3D CNN model", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 663, + 484, + 677 + ], + "spans": [ + { + "bbox": [ + 106, + 663, + 124, + 676 + ], + "score": 0.9, + "content": "f ( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 124, + 664, + 484, + 677 + ], + "score": 1.0, + "content": "for spatiotemporal representation learning with a non-local operation (Wang et al., 2018):", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 30 + }, + { + "type": "interline_equation", + "bbox": [ + 246, + 680, + 364, + 694 + ], + "lines": [ + { + "bbox": [ + 246, + 680, + 364, + 694 + ], + "spans": [ + { + "bbox": [ + 246, + 680, + 364, + 694 + ], + "score": 0.94, + "content": "f _ { \\mathrm { N L } } ( \\widetilde { \\mathbf { x } } _ { i } ) = \\mathrm { N L } ( f ( \\widetilde { \\mathbf { x } } _ { i } ) , f ( \\pmb { x } ) ) ,", + "type": "interline_equation", + "image_path": "f32191da64c9aca571754c11df4aab1017c36080d410c7cff291db8af555d770.jpg" + } + ] + } + ], + "index": 35, + "virtual_lines": [ + { + "bbox": [ + 246, + 680, + 364, + 694 + ], + "spans": [], + "index": 35 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 698, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 697, + 504, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 133, + 712 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 699, + 166, + 711 + ], + "score": 0.91, + "content": "\\operatorname { N L } ( \\cdot , \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 697, + 316, + 712 + ], + "score": 1.0, + "content": "denotes the non-local operator, and", + "type": "text" + }, + { + "bbox": [ + 316, + 698, + 340, + 711 + ], + "score": 0.92, + "content": "f ( \\widetilde { \\pmb x } _ { i } )", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 697, + 360, + 712 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 361, + 699, + 382, + 711 + ], + "score": 0.92, + "content": "f ( { \\pmb x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 697, + 492, + 712 + ], + "score": 1.0, + "content": "denote the feature map of", + "type": "text" + }, + { + "bbox": [ + 493, + 699, + 504, + 710 + ], + "score": 0.86, + "content": "\\widetilde { \\pmb { x } } _ { i }", + "type": "inline_equation" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 709, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 124, + 722 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 124, + 712, + 132, + 720 + ], + "score": 0.73, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 709, + 283, + 722 + ], + "score": 1.0, + "content": "from the last convolutional layer of", + "type": "text" + }, + { + "bbox": [ + 284, + 710, + 300, + 722 + ], + "score": 0.91, + "content": "f ( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 301, + 709, + 470, + 722 + ], + "score": 1.0, + "content": "e, respectively. The resultant feature map", + "type": "text" + }, + { + "bbox": [ + 470, + 710, + 504, + 722 + ], + "score": 0.92, + "content": "f _ { \\mathrm { N L } } ( \\widetilde { \\pmb x } _ { i } )", + "type": "inline_equation" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "eis further passed through a spatial pooling layer followed by a separately fully-connected layer for", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 306, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 759 + ], + "lines": [] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 118, + 81, + 488, + 280 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 118, + 81, + 488, + 280 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 118, + 81, + 488, + 280 + ], + "spans": [ + { + "bbox": [ + 118, + 81, + 488, + 280 + ], + "score": 0.974, + "type": "image", + "image_path": "1078e24fffb3ba13c20ebafabd92aee164ef40d676a91283df6ddb5e42457aac.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 118, + 81, + 488, + 147.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 118, + 147.33333333333331, + 488, + 213.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 118, + 213.66666666666663, + 488, + 279.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 284, + 505, + 339 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 283, + 505, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 283, + 505, + 297 + ], + "score": 1.0, + "content": "Figure 2: (a) Illustration of our Constrained Spatiotemporal Jigsaw (CSJ) (see Sec. 3.2). (b) The", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 295, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 505, + 308 + ], + "score": 1.0, + "content": "pipeline of our proposed framework for self-supervised video representation learning (see Sec. 3.3).", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 104, + 304, + 505, + 321 + ], + "spans": [ + { + "bbox": [ + 104, + 304, + 505, + 321 + ], + "score": 1.0, + "content": "A raw video clip is transformed into 8 shuffled clips with our Constrained Spatiotemporal Jig-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 316, + 506, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 316, + 506, + 331 + ], + "score": 1.0, + "content": "saw (CSJ), and a 3D CNN sharing weights extracts the feature representations from them. The", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 327, + 372, + 341 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 372, + 341 + ], + "score": 1.0, + "content": "model is then trained by solving four self-supervised tasks jointly.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5 + } + ], + "index": 3.0 + }, + { + "type": "text", + "bbox": [ + 107, + 352, + 505, + 397 + ], + "lines": [], + "index": 9.5, + "bbox_fs": [ + 104, + 351, + 506, + 402 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 402, + 505, + 545 + ], + "lines": [ + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "score": 1.0, + "content": "We introduce two permutation strategies to ensure that the volumes of LCCs are large in relation to", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 411, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 360, + 426 + ], + "score": 1.0, + "content": "the whole video clip volume after our shuffling transformation", + "type": "text" + }, + { + "bbox": [ + 360, + 412, + 396, + 424 + ], + "score": 0.92, + "content": "t ( \\cdot ; \\theta _ { \\mathrm { C S J } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 411, + 506, + 426 + ], + "score": 1.0, + "content": ". First, instead of shuffling", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 424, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 106, + 425, + 114, + 434 + ], + "score": 0.73, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 115, + 424, + 323, + 437 + ], + "score": 1.0, + "content": "in three spatiotemporal dimensions simultaneously,", + "type": "text" + }, + { + "bbox": [ + 323, + 424, + 360, + 436 + ], + "score": 0.92, + "content": "t ( \\cdot ; \\theta _ { \\mathrm { C S J } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 424, + 505, + 437 + ], + "score": 1.0, + "content": "factorizes the permutations into the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 433, + 506, + 449 + ], + "spans": [ + { + "bbox": [ + 104, + 433, + 506, + 449 + ], + "score": 1.0, + "content": "three spatiotemporal dimensions and then utilizes them sequentially to generate shuffled clips, e.g.,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 446, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 169, + 459 + ], + "score": 1.0, + "content": "in the order of", + "type": "text" + }, + { + "bbox": [ + 169, + 446, + 205, + 457 + ], + "score": 0.91, + "content": "T , W , H", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 446, + 433, + 459 + ], + "score": 1.0, + "content": "and only once. Note that the volume of the generated", + "type": "text" + }, + { + "bbox": [ + 433, + 446, + 441, + 456 + ], + "score": 0.81, + "content": "\\widetilde { \\pmb x }", + "type": "inline_equation" + }, + { + "bbox": [ + 442, + 446, + 506, + 459 + ], + "score": 1.0, + "content": "stays the same", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 456, + 505, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 266, + 470 + ], + "score": 1.0, + "content": "with different permutation orders (e.g.,", + "type": "text" + }, + { + "bbox": [ + 267, + 457, + 295, + 467 + ], + "score": 0.33, + "content": "T W H", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 456, + 314, + 470 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 314, + 457, + 343, + 467 + ], + "score": 0.29, + "content": "H T W", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 456, + 505, + 470 + ], + "score": 1.0, + "content": "e). Second, we shuffle a group of jigsaw", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 466, + 506, + 481 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 506, + 481 + ], + "score": 1.0, + "content": "pieces together instead of each piece individually along each dimension. Taking spatial shuffling as", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 479, + 506, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 479, + 460, + 491 + ], + "score": 1.0, + "content": "an example, if there are 8 pieces per frame (along each of the two spatial dimensions),", + "type": "text" + }, + { + "bbox": [ + 460, + 479, + 479, + 490 + ], + "score": 0.89, + "content": "\\theta _ { \\mathrm { C S J } }", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 479, + 506, + 491 + ], + "score": 1.0, + "content": "could", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 489, + 506, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 268, + 502 + ], + "score": 1.0, + "content": "be represented as the permutation from", + "type": "text" + }, + { + "bbox": [ + 268, + 489, + 319, + 501 + ], + "score": 0.92, + "content": "\\{ 1 2 3 4 5 6 7 8 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 319, + 489, + 332, + 502 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 332, + 489, + 382, + 501 + ], + "score": 0.86, + "content": "\\{ 8 4 5 6 7 1 2 3 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 489, + 506, + 502 + ], + "score": 1.0, + "content": ". The longest and the second-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 104, + 500, + 506, + 514 + ], + "spans": [ + { + "bbox": [ + 104, + 500, + 304, + 514 + ], + "score": 1.0, + "content": "longest index ranges are: [2, 5] for coordinates", + "type": "text" + }, + { + "bbox": [ + 305, + 501, + 335, + 512 + ], + "score": 0.92, + "content": "\\{ 4 5 6 7 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 500, + 448, + 514 + ], + "score": 1.0, + "content": ", and [6, 8] for coordinates", + "type": "text" + }, + { + "bbox": [ + 449, + 500, + 474, + 513 + ], + "score": 0.86, + "content": "\\lbrace 1 2 3 \\rbrace", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 500, + 506, + 514 + ], + "score": 1.0, + "content": ". With", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 511, + 506, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 506, + 524 + ], + "score": 1.0, + "content": "these two permutation strategies, not only do we have large LCCs, but also they are guaranteed to", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 523, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 505, + 534 + ], + "score": 1.0, + "content": "have clearly separable boundaries (see Fig. 2(b)) with surrounding pieces due to the factorized and", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 533, + 394, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 394, + 547 + ], + "score": 1.0, + "content": "grouped permutation design. This means that they are easily detectable.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 18, + "bbox_fs": [ + 104, + 402, + 506, + 547 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 555, + 214, + 567 + ], + "lines": [ + { + "bbox": [ + 105, + 554, + 216, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 216, + 568 + ], + "score": 1.0, + "content": "3.3 SURROGATE TASKS", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 576, + 505, + 675 + ], + "lines": [ + { + "bbox": [ + 106, + 576, + 505, + 589 + ], + "spans": [ + { + "bbox": [ + 106, + 576, + 505, + 589 + ], + "score": 1.0, + "content": "Having permutation constraints preserves more spatiotemporal continuity in the shuffled clip and re-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 586, + 506, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 506, + 600 + ], + "score": 1.0, + "content": "duces the amount of possible permutations. But exploiting these constraints to make a neural sorting", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 597, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 426, + 611 + ], + "score": 1.0, + "content": "model tractable is still far from trivial. Instead of solving the jigsaw directly, our", + "type": "text" + }, + { + "bbox": [ + 427, + 598, + 446, + 609 + ], + "score": 0.9, + "content": "P _ { \\mathrm { C S J } }", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 597, + 505, + 611 + ], + "score": 1.0, + "content": "is thus formu-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 608, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 608, + 505, + 622 + ], + "score": 1.0, + "content": "lated as four surrogate tasks: Largest Continuous Cuboid Detection (LCCD), Clip Shuffling Pattern", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 618, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 505, + 633 + ], + "score": 1.0, + "content": "Classification (CSPC), Contrastive Learning over Shuffled Clips (CLSC), and Clip Continuity Mea-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 630, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 415, + 643 + ], + "score": 1.0, + "content": "sure Regression (CCMR). As illustrated in Fig. 2(b), given an unlabeled clip", + "type": "text" + }, + { + "bbox": [ + 415, + 633, + 423, + 641 + ], + "score": 0.72, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 630, + 505, + 643 + ], + "score": 1.0, + "content": ", we first construct a", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 640, + 505, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 191, + 655 + ], + "score": 1.0, + "content": "mini-batch of 8 clips", + "type": "text" + }, + { + "bbox": [ + 192, + 641, + 257, + 654 + ], + "score": 0.92, + "content": "\\{ \\widetilde { \\pmb { x } } _ { 1 } , \\widetilde { \\pmb { x } } _ { 2 } , . . . , \\widetilde { \\pmb { x } } _ { 8 } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 640, + 308, + 655 + ], + "score": 1.0, + "content": "by shuffling", + "type": "text" + }, + { + "bbox": [ + 308, + 644, + 316, + 652 + ], + "score": 0.77, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 640, + 505, + 655 + ], + "score": 1.0, + "content": "with different but related constrained permuta-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 652, + 505, + 665 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 358, + 665 + ], + "score": 1.0, + "content": "e e etions (to be detailed later). These shuffled clips and the raw clip", + "type": "text" + }, + { + "bbox": [ + 359, + 654, + 367, + 663 + ], + "score": 0.76, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 652, + 505, + 665 + ], + "score": 1.0, + "content": "are then fed into a 3D CNN model", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 663, + 484, + 677 + ], + "spans": [ + { + "bbox": [ + 106, + 663, + 124, + 676 + ], + "score": 0.9, + "content": "f ( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 124, + 664, + 484, + 677 + ], + "score": 1.0, + "content": "for spatiotemporal representation learning with a non-local operation (Wang et al., 2018):", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 30, + "bbox_fs": [ + 105, + 576, + 506, + 677 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 246, + 680, + 364, + 694 + ], + "lines": [ + { + "bbox": [ + 246, + 680, + 364, + 694 + ], + "spans": [ + { + "bbox": [ + 246, + 680, + 364, + 694 + ], + "score": 0.94, + "content": "f _ { \\mathrm { N L } } ( \\widetilde { \\mathbf { x } } _ { i } ) = \\mathrm { N L } ( f ( \\widetilde { \\mathbf { x } } _ { i } ) , f ( \\pmb { x } ) ) ,", + "type": "interline_equation", + "image_path": "f32191da64c9aca571754c11df4aab1017c36080d410c7cff291db8af555d770.jpg" + } + ] + } + ], + "index": 35, + "virtual_lines": [ + { + "bbox": [ + 246, + 680, + 364, + 694 + ], + "spans": [], + "index": 35 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 698, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 697, + 504, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 133, + 712 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 699, + 166, + 711 + ], + "score": 0.91, + "content": "\\operatorname { N L } ( \\cdot , \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 697, + 316, + 712 + ], + "score": 1.0, + "content": "denotes the non-local operator, and", + "type": "text" + }, + { + "bbox": [ + 316, + 698, + 340, + 711 + ], + "score": 0.92, + "content": "f ( \\widetilde { \\pmb x } _ { i } )", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 697, + 360, + 712 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 361, + 699, + 382, + 711 + ], + "score": 0.92, + "content": "f ( { \\pmb x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 697, + 492, + 712 + ], + "score": 1.0, + "content": "denote the feature map of", + "type": "text" + }, + { + "bbox": [ + 493, + 699, + 504, + 710 + ], + "score": 0.86, + "content": "\\widetilde { \\pmb { x } } _ { i }", + "type": "inline_equation" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 709, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 124, + 722 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 124, + 712, + 132, + 720 + ], + "score": 0.73, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 709, + 283, + 722 + ], + "score": 1.0, + "content": "from the last convolutional layer of", + "type": "text" + }, + { + "bbox": [ + 284, + 710, + 300, + 722 + ], + "score": 0.91, + "content": "f ( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 301, + 709, + 470, + 722 + ], + "score": 1.0, + "content": "e, respectively. The resultant feature map", + "type": "text" + }, + { + "bbox": [ + 470, + 710, + 504, + 722 + ], + "score": 0.92, + "content": "f _ { \\mathrm { N L } } ( \\widetilde { \\pmb x } _ { i } )", + "type": "inline_equation" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "eis further passed through a spatial pooling layer followed by a separately fully-connected layer for", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 82, + 504, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 334, + 95 + ], + "score": 1.0, + "content": "each surrogate task. Note that the raw video feature map", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 334, + 83, + 356, + 95 + ], + "score": 0.92, + "content": "f ( { \\pmb x } )", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 356, + 82, + 504, + 95 + ], + "score": 1.0, + "content": "is used as guidance through the non-", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "local based attention mechanism to help fulfill the tasks. This is similar to humans needing to see", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 105, + 322, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 322, + 117 + ], + "score": 1.0, + "content": "the completed jigsaw picture to help solve the puzzle.", + "type": "text", + "cross_page": true + } + ], + "index": 2 + } + ], + "index": 37, + "bbox_fs": [ + 105, + 697, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 504, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 334, + 95 + ], + "score": 1.0, + "content": "each surrogate task. Note that the raw video feature map", + "type": "text" + }, + { + "bbox": [ + 334, + 83, + 356, + 95 + ], + "score": 0.92, + "content": "f ( { \\pmb x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 82, + 504, + 95 + ], + "score": 1.0, + "content": "is used as guidance through the non-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "local based attention mechanism to help fulfill the tasks. This is similar to humans needing to see", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 105, + 322, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 322, + 117 + ], + "score": 1.0, + "content": "the completed jigsaw picture to help solve the puzzle.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 106, + 121, + 505, + 221 + ], + "lines": [ + { + "bbox": [ + 106, + 121, + 504, + 134 + ], + "spans": [ + { + "bbox": [ + 106, + 121, + 504, + 134 + ], + "score": 1.0, + "content": "Before we detail the four tasks, we first explain how the eight permutations from the same raw clip", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 132, + 506, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 408, + 145 + ], + "score": 1.0, + "content": "are generated. First, the factorized and grouped permutations are applied to", + "type": "text" + }, + { + "bbox": [ + 408, + 134, + 416, + 142 + ], + "score": 0.73, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 416, + 132, + 506, + 145 + ], + "score": 1.0, + "content": "to create one shuffled", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 143, + 506, + 156 + ], + "spans": [ + { + "bbox": [ + 106, + 143, + 506, + 156 + ], + "score": 1.0, + "content": "clip. By examining the largest and the second-largest continuous puzzle piece numbers of each", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 153, + 506, + 168 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 151, + 168 + ], + "score": 1.0, + "content": "dimension", + "type": "text" + }, + { + "bbox": [ + 151, + 154, + 202, + 166 + ], + "score": 0.91, + "content": "( \\{ T , H , \\bar { W } \\} )", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 153, + 506, + 168 + ], + "score": 1.0, + "content": ", we can easily identify the top-2 largest continuous cuboids (LCCs). Next,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 165, + 506, + 179 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 506, + 179 + ], + "score": 1.0, + "content": "by varying the relative order of the top-2 LCCs either in the correct (original) order or the reverse", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 176, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 106, + 176, + 210, + 189 + ], + "score": 1.0, + "content": "order in each dimension,", + "type": "text" + }, + { + "bbox": [ + 211, + 176, + 256, + 187 + ], + "score": 0.9, + "content": "2 \\times 2 \\times 2 { = } 8", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 176, + 505, + 189 + ], + "score": 1.0, + "content": "permutations are obtained. By controlling the group size in", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 504, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 484, + 200 + ], + "score": 1.0, + "content": "permutation, we can make sure that the top-2 LCCs account for a large proportion, saying", + "type": "text" + }, + { + "bbox": [ + 484, + 187, + 504, + 198 + ], + "score": 0.84, + "content": "80 \\%", + "type": "inline_equation" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 505, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 505, + 211 + ], + "score": 1.0, + "content": "of the total clip volume. Our four tasks are thus centered around these two LCCs as they largely", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 209, + 377, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 377, + 222 + ], + "score": 1.0, + "content": "determine the overall spatiotemporal continuity of the shuffled clip.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 106, + 225, + 505, + 321 + ], + "lines": [ + { + "bbox": [ + 104, + 223, + 506, + 241 + ], + "spans": [ + { + "bbox": [ + 104, + 223, + 299, + 241 + ], + "score": 1.0, + "content": "The first task LCCD is to locate the top-2 LCCs", + "type": "text" + }, + { + "bbox": [ + 300, + 225, + 381, + 238 + ], + "score": 0.9, + "content": "\\{ c _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } } ( j ) : j = 1 , 2 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 223, + 506, + 241 + ], + "score": 1.0, + "content": "and formulated as a regression", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 104, + 234, + 507, + 253 + ], + "spans": [ + { + "bbox": [ + 104, + 234, + 254, + 253 + ], + "score": 1.0, + "content": "problem. Given a ground-truth LCC", + "type": "text" + }, + { + "bbox": [ + 254, + 237, + 285, + 249 + ], + "score": 0.92, + "content": "c _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } } ( j )", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 234, + 507, + 253 + ], + "score": 1.0, + "content": ", a Gaussian kernel is applied to its center to depict the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 102, + 244, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 102, + 244, + 214, + 267 + ], + "score": 1.0, + "content": "possibility of each pixel in", + "type": "text" + }, + { + "bbox": [ + 214, + 250, + 222, + 260 + ], + "score": 0.81, + "content": "\\widetilde { \\pmb x }", + "type": "inline_equation" + }, + { + "bbox": [ + 223, + 244, + 416, + 267 + ], + "score": 1.0, + "content": "belonging to the LCC. This leads to a soft mask", + "type": "text" + }, + { + "bbox": [ + 416, + 248, + 446, + 262 + ], + "score": 0.92, + "content": "M _ { \\mathrm { L C C D } } ^ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 446, + 244, + 505, + 267 + ], + "score": 1.0, + "content": "with the same", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 262, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 104, + 264, + 136, + 284 + ], + "score": 1.0, + "content": "size of", + "type": "text" + }, + { + "bbox": [ + 137, + 268, + 144, + 279 + ], + "score": 0.66, + "content": "\\widetilde { \\pmb x }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 264, + 150, + 284 + ], + "score": 1.0, + "content": ":", + "type": "text" + }, + { + "bbox": [ + 150, + 267, + 180, + 281 + ], + "score": 0.91, + "content": "M _ { \\mathrm { L C C D } } ^ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 264, + 299, + 284 + ], + "score": 1.0, + "content": "is all 0 outside the region of", + "type": "text" + }, + { + "bbox": [ + 300, + 268, + 330, + 281 + ], + "score": 0.93, + "content": "c _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } } ( j )", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 264, + 353, + 284 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 353, + 262, + 430, + 289 + ], + "score": 0.94, + "content": "\\exp \\bigl ( - \\frac { | | \\boldsymbol { a } - \\boldsymbol { a } _ { \\mathrm { c } } | | ^ { 2 } } { 2 \\sigma _ { g } ^ { 2 } } \\bigr )", + "type": "inline_equation" + }, + { + "bbox": [ + 431, + 266, + 505, + 282 + ], + "score": 1.0, + "content": "inside the region,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 287, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 106, + 287, + 133, + 300 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 289, + 156, + 299 + ], + "score": 0.88, + "content": "{ \\mathbf { } } a , a _ { \\mathrm { { c } } }", + "type": "inline_equation" + }, + { + "bbox": [ + 156, + 287, + 370, + 300 + ], + "score": 1.0, + "content": "denote any pixel and the center point, respectively.", + "type": "text" + }, + { + "bbox": [ + 370, + 290, + 382, + 299 + ], + "score": 0.83, + "content": "\\sigma _ { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 287, + 505, + 300 + ], + "score": 1.0, + "content": "is the hyper-parameter which", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 297, + 506, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 506, + 311 + ], + "score": 1.0, + "content": "is set as 1 empirically. In the training stage, FPN (Lin et al., 2017) is used for multi-level feature", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 309, + 354, + 321 + ], + "spans": [ + { + "bbox": [ + 106, + 309, + 354, + 321 + ], + "score": 1.0, + "content": "fusion. LCCD is optimized using the MSE loss in each point:", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15 + }, + { + "type": "interline_equation", + "bbox": [ + 199, + 324, + 410, + 353 + ], + "lines": [ + { + "bbox": [ + 199, + 324, + 410, + 353 + ], + "spans": [ + { + "bbox": [ + 199, + 324, + 410, + 353 + ], + "score": 0.92, + "content": "{ \\cal L } _ { \\mathrm { L C C D } } = \\sum _ { j \\in \\{ 1 , 2 \\} } \\sum _ { { \\bf { a } } \\in \\widetilde { { \\pmb x } } } \\mathrm { M S E } ( M _ { \\mathrm { L C C D } } ^ { j } ( { \\pmb a } ) , M _ { \\mathrm { L C C D } } ^ { j } ( { \\pmb a } ) ^ { ' } ) ,", + "type": "interline_equation", + "image_path": "949b6cc4924d36c2320f85c899cd367cdea3c3fb35cbfc206596dabb9032cf9e.jpg" + } + ] + } + ], + "index": 19.5, + "virtual_lines": [ + { + "bbox": [ + 199, + 324, + 410, + 338.5 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 199, + 338.5, + 410, + 353.0 + ], + "spans": [], + "index": 20 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 358, + 497, + 373 + ], + "lines": [ + { + "bbox": [ + 105, + 358, + 494, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 133, + 374 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 360, + 173, + 372 + ], + "score": 0.84, + "content": "\\mathrm { M S E } ( \\cdot , \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 358, + 318, + 374 + ], + "score": 1.0, + "content": "denotes the MSE loss function, and", + "type": "text" + }, + { + "bbox": [ + 318, + 358, + 363, + 373 + ], + "score": 0.93, + "content": "M _ { \\mathrm { L C C D } } ^ { j } ( \\pmb { a } ) ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 358, + 487, + 374 + ], + "score": 1.0, + "content": "0 is the prediction of each pixel", + "type": "text" + }, + { + "bbox": [ + 487, + 362, + 494, + 370 + ], + "score": 0.71, + "content": "^ { a }", + "type": "inline_equation" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 106, + 377, + 505, + 444 + ], + "lines": [ + { + "bbox": [ + 106, + 378, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 106, + 378, + 505, + 389 + ], + "score": 1.0, + "content": "CSPC is designed to recognize the shuffling pattern of a shuffled clip. As mentioned early, the eight", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 388, + 505, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 505, + 401 + ], + "score": 1.0, + "content": "shuffled clips in each mini-batch are created from the same raw clip and differ only in the relative", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "score": 1.0, + "content": "order of the top-2 LCCs along each of the three dimensions. There are thus eight permutations", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 411, + 505, + 422 + ], + "spans": [ + { + "bbox": [ + 106, + 411, + 505, + 422 + ], + "score": 1.0, + "content": "depending on the order (correct or reverse) in each dimension. Based on this understanding, CSPC", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 104, + 420, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 104, + 420, + 505, + 434 + ], + "score": 1.0, + "content": "is formulated as a multi-class classification task to recognize each shuffled clip into one of these", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 433, + 381, + 444 + ], + "spans": [ + { + "bbox": [ + 106, + 433, + 381, + 444 + ], + "score": 1.0, + "content": "eight classes, which is optimized using the Cross-Entropy (CE) loss:", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24.5 + }, + { + "type": "interline_equation", + "bbox": [ + 220, + 447, + 390, + 477 + ], + "lines": [ + { + "bbox": [ + 220, + 447, + 390, + 477 + ], + "spans": [ + { + "bbox": [ + 220, + 447, + 390, + 477 + ], + "score": 0.94, + "content": "L _ { \\mathrm { C S P C } } = \\sum _ { i \\in \\{ 0 , 1 , . . . , 7 \\} } { \\bf C E } ( l _ { \\mathrm { C S P C } } [ i ] , l _ { \\mathrm { C S P C } } ^ { ' } [ i ] ) ,", + "type": "interline_equation", + "image_path": "48e20e210dbec32facf8e5632a608c134ac60fdde0191ac8ce01ea94d87dae04.jpg" + } + ] + } + ], + "index": 28.5, + "virtual_lines": [ + { + "bbox": [ + 220, + 447, + 390, + 462.0 + ], + "spans": [], + "index": 28 + }, + { + "bbox": [ + 220, + 462.0, + 390, + 477.0 + ], + "spans": [], + "index": 29 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 482, + 504, + 506 + ], + "lines": [ + { + "bbox": [ + 105, + 481, + 506, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 481, + 133, + 497 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 483, + 165, + 495 + ], + "score": 0.9, + "content": "\\operatorname { C E } ( \\cdot , \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 481, + 303, + 497 + ], + "score": 1.0, + "content": "denotes the CE loss function and", + "type": "text" + }, + { + "bbox": [ + 304, + 481, + 334, + 496 + ], + "score": 0.93, + "content": "l _ { \\mathrm { C S P C } } ^ { ' } [ i ]", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 481, + 457, + 497 + ], + "score": 1.0, + "content": "is the predicted class label of", + "type": "text" + }, + { + "bbox": [ + 457, + 484, + 461, + 493 + ], + "score": 0.79, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 481, + 506, + 497 + ], + "score": 1.0, + "content": "-th sample", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 494, + 245, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 245, + 506 + ], + "score": 1.0, + "content": "(shuffled clip) in each mini-batch.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5 + }, + { + "type": "text", + "bbox": [ + 106, + 510, + 505, + 600 + ], + "lines": [ + { + "bbox": [ + 106, + 511, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 505, + 524 + ], + "score": 1.0, + "content": "The two tasks above emphasize on local spatiotemporal continuity understanding. In contrast,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 522, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 505, + 535 + ], + "score": 1.0, + "content": "CLSC leverages the contrastive loss to encourage global continuity understanding. In particular,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 533, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 506, + 545 + ], + "score": 1.0, + "content": "since the top-2 LCCs dominate the volume of a clip, it is safe to assume that if their relative order is", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 544, + 505, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 505, + 557 + ], + "score": 1.0, + "content": "correct in all three dimensions, the shuffled clip largely preserve continuity compared to the original", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 555, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 106, + 555, + 505, + 568 + ], + "score": 1.0, + "content": "clip, while all other 7 permutations feature large discontinuity in at least one dimension. We thus", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 566, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 333, + 578 + ], + "score": 1.0, + "content": "form a contrastive learning task with the original video", + "type": "text" + }, + { + "bbox": [ + 333, + 568, + 342, + 576 + ], + "score": 0.73, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 566, + 505, + 578 + ], + "score": 1.0, + "content": "and the most continuous shuffled video", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 107, + 577, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 107, + 578, + 117, + 588 + ], + "score": 0.87, + "content": "\\widetilde { \\pmb { x } } _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 118, + 578, + 208, + 590 + ], + "score": 1.0, + "content": "as a positive pair, and", + "type": "text" + }, + { + "bbox": [ + 209, + 579, + 217, + 587 + ], + "score": 0.79, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 578, + 267, + 590 + ], + "score": 1.0, + "content": "and the rest", + "type": "text" + }, + { + "bbox": [ + 267, + 577, + 279, + 589 + ], + "score": 0.84, + "content": "\\widetilde { \\pmb { x } } _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 577, + 310, + 589 + ], + "score": 0.7, + "content": "( j \\neq i )", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 578, + 505, + 590 + ], + "score": 1.0, + "content": ") as negative pairs. CLSC is optimized using the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 587, + 350, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 350, + 600 + ], + "score": 1.0, + "content": "e eNoise Contrastive Estimation (NCE) (Tian et al., 2020) loss:", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 35.5 + }, + { + "type": "interline_equation", + "bbox": [ + 154, + 603, + 456, + 632 + ], + "lines": [ + { + "bbox": [ + 154, + 603, + 456, + 632 + ], + "spans": [ + { + "bbox": [ + 154, + 603, + 456, + 632 + ], + "score": 0.92, + "content": "\\begin{array} { r } { L _ { \\mathrm { C L S C } } = - \\log \\frac { \\exp ( \\sin ( f ( \\pmb { x } ) , f ( \\widetilde { \\pmb { x } } _ { i } ) ) / \\tau ) } { \\exp ( \\sin ( f ( \\pmb { x } ) , f ( \\widetilde { \\pmb { x } } _ { i } ) ) / \\tau ) + \\sum _ { j } \\exp ( \\sin ( f ( \\pmb { x } ) , f ( \\widetilde { \\pmb { x } } _ { j } ) ) / \\tau ) } , } \\end{array}", + "type": "interline_equation", + "image_path": "eb953d201cb8d73386a8cee9aa86599758df0af996550c66f5ea9c315298fe77.jpg" + } + ] + } + ], + "index": 41, + "virtual_lines": [ + { + "bbox": [ + 154, + 603, + 456, + 612.6666666666666 + ], + "spans": [], + "index": 40 + }, + { + "bbox": [ + 154, + 612.6666666666666, + 456, + 622.3333333333333 + ], + "spans": [], + "index": 41 + }, + { + "bbox": [ + 154, + 622.3333333333333, + 456, + 631.9999999999999 + ], + "spans": [], + "index": 42 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 636, + 503, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 636, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 133, + 651 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 638, + 166, + 650 + ], + "score": 0.91, + "content": "\\sin ( \\cdot , \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 636, + 284, + 651 + ], + "score": 1.0, + "content": "is defined by the dot product:", + "type": "text" + }, + { + "bbox": [ + 284, + 636, + 335, + 650 + ], + "score": 0.93, + "content": "f ( \\pmb { x } ) ^ { \\top } f ( \\widetilde { \\pmb { x } } _ { i } )", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 636, + 355, + 651 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 355, + 640, + 362, + 648 + ], + "score": 0.79, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 636, + 505, + 651 + ], + "score": 1.0, + "content": "is the temperature hyper-parameter.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 649, + 321, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 321, + 660 + ], + "score": 1.0, + "content": "Note that the non-local operator is not used in CLSC.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43.5 + }, + { + "type": "text", + "bbox": [ + 106, + 665, + 505, + 735 + ], + "lines": [ + { + "bbox": [ + 106, + 666, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 505, + 677 + ], + "score": 1.0, + "content": "CCMR is similar to CLSC in that it also enforces global continuity understanding, but differs in", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "that it is a regression task aimed at predicting a global continuity measure. We consider two such", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 103, + 684, + 508, + 704 + ], + "spans": [ + { + "bbox": [ + 103, + 684, + 308, + 704 + ], + "score": 1.0, + "content": "measures. Since the total size of the top-2 LCCs", + "type": "text" + }, + { + "bbox": [ + 309, + 687, + 394, + 700 + ], + "score": 0.9, + "content": "\\{ c _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } } ( j ) : j = 1 , 2 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 394, + 684, + 508, + 704 + ], + "score": 1.0, + "content": "is a good indicator of how", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 318, + 712 + ], + "score": 1.0, + "content": "continuous a shuffle video clip is, the first measure", + "type": "text" + }, + { + "bbox": [ + 318, + 700, + 330, + 710 + ], + "score": 0.88, + "content": "l _ { l d }", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "directly measures the relative total size of", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 706, + 504, + 735 + ], + "spans": [ + { + "bbox": [ + 105, + 706, + 173, + 729 + ], + "score": 1.0, + "content": "the top-2 LCCs:", + "type": "text" + }, + { + "bbox": [ + 173, + 709, + 299, + 735 + ], + "score": 0.93, + "content": "l _ { l d } = \\frac { \\mathbf { v } ( { c } _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } } ( 1 ) ) + \\mathbf { v } ( { c } _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } } ( 2 ) ) } { \\mathbf { v } ( \\widetilde { \\pmb { x } } ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 299, + 706, + 330, + 729 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 330, + 716, + 346, + 728 + ], + "score": 0.87, + "content": "\\mathbf { v } ( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 706, + 504, + 729 + ], + "score": 1.0, + "content": "represents the volume of a clip/cuboid.", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 47 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "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" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 116 + ], + "lines": [], + "index": 1, + "bbox_fs": [ + 105, + 82, + 505, + 117 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 121, + 505, + 221 + ], + "lines": [ + { + "bbox": [ + 106, + 121, + 504, + 134 + ], + "spans": [ + { + "bbox": [ + 106, + 121, + 504, + 134 + ], + "score": 1.0, + "content": "Before we detail the four tasks, we first explain how the eight permutations from the same raw clip", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 132, + 506, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 408, + 145 + ], + "score": 1.0, + "content": "are generated. First, the factorized and grouped permutations are applied to", + "type": "text" + }, + { + "bbox": [ + 408, + 134, + 416, + 142 + ], + "score": 0.73, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 416, + 132, + 506, + 145 + ], + "score": 1.0, + "content": "to create one shuffled", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 143, + 506, + 156 + ], + "spans": [ + { + "bbox": [ + 106, + 143, + 506, + 156 + ], + "score": 1.0, + "content": "clip. By examining the largest and the second-largest continuous puzzle piece numbers of each", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 153, + 506, + 168 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 151, + 168 + ], + "score": 1.0, + "content": "dimension", + "type": "text" + }, + { + "bbox": [ + 151, + 154, + 202, + 166 + ], + "score": 0.91, + "content": "( \\{ T , H , \\bar { W } \\} )", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 153, + 506, + 168 + ], + "score": 1.0, + "content": ", we can easily identify the top-2 largest continuous cuboids (LCCs). Next,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 165, + 506, + 179 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 506, + 179 + ], + "score": 1.0, + "content": "by varying the relative order of the top-2 LCCs either in the correct (original) order or the reverse", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 176, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 106, + 176, + 210, + 189 + ], + "score": 1.0, + "content": "order in each dimension,", + "type": "text" + }, + { + "bbox": [ + 211, + 176, + 256, + 187 + ], + "score": 0.9, + "content": "2 \\times 2 \\times 2 { = } 8", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 176, + 505, + 189 + ], + "score": 1.0, + "content": "permutations are obtained. By controlling the group size in", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 504, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 484, + 200 + ], + "score": 1.0, + "content": "permutation, we can make sure that the top-2 LCCs account for a large proportion, saying", + "type": "text" + }, + { + "bbox": [ + 484, + 187, + 504, + 198 + ], + "score": 0.84, + "content": "80 \\%", + "type": "inline_equation" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 505, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 505, + 211 + ], + "score": 1.0, + "content": "of the total clip volume. Our four tasks are thus centered around these two LCCs as they largely", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 209, + 377, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 377, + 222 + ], + "score": 1.0, + "content": "determine the overall spatiotemporal continuity of the shuffled clip.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 7, + "bbox_fs": [ + 105, + 121, + 506, + 222 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 225, + 505, + 321 + ], + "lines": [ + { + "bbox": [ + 104, + 223, + 506, + 241 + ], + "spans": [ + { + "bbox": [ + 104, + 223, + 299, + 241 + ], + "score": 1.0, + "content": "The first task LCCD is to locate the top-2 LCCs", + "type": "text" + }, + { + "bbox": [ + 300, + 225, + 381, + 238 + ], + "score": 0.9, + "content": "\\{ c _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } } ( j ) : j = 1 , 2 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 223, + 506, + 241 + ], + "score": 1.0, + "content": "and formulated as a regression", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 104, + 234, + 507, + 253 + ], + "spans": [ + { + "bbox": [ + 104, + 234, + 254, + 253 + ], + "score": 1.0, + "content": "problem. Given a ground-truth LCC", + "type": "text" + }, + { + "bbox": [ + 254, + 237, + 285, + 249 + ], + "score": 0.92, + "content": "c _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } } ( j )", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 234, + 507, + 253 + ], + "score": 1.0, + "content": ", a Gaussian kernel is applied to its center to depict the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 102, + 244, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 102, + 244, + 214, + 267 + ], + "score": 1.0, + "content": "possibility of each pixel in", + "type": "text" + }, + { + "bbox": [ + 214, + 250, + 222, + 260 + ], + "score": 0.81, + "content": "\\widetilde { \\pmb x }", + "type": "inline_equation" + }, + { + "bbox": [ + 223, + 244, + 416, + 267 + ], + "score": 1.0, + "content": "belonging to the LCC. This leads to a soft mask", + "type": "text" + }, + { + "bbox": [ + 416, + 248, + 446, + 262 + ], + "score": 0.92, + "content": "M _ { \\mathrm { L C C D } } ^ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 446, + 244, + 505, + 267 + ], + "score": 1.0, + "content": "with the same", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 262, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 104, + 264, + 136, + 284 + ], + "score": 1.0, + "content": "size of", + "type": "text" + }, + { + "bbox": [ + 137, + 268, + 144, + 279 + ], + "score": 0.66, + "content": "\\widetilde { \\pmb x }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 264, + 150, + 284 + ], + "score": 1.0, + "content": ":", + "type": "text" + }, + { + "bbox": [ + 150, + 267, + 180, + 281 + ], + "score": 0.91, + "content": "M _ { \\mathrm { L C C D } } ^ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 264, + 299, + 284 + ], + "score": 1.0, + "content": "is all 0 outside the region of", + "type": "text" + }, + { + "bbox": [ + 300, + 268, + 330, + 281 + ], + "score": 0.93, + "content": "c _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } } ( j )", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 264, + 353, + 284 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 353, + 262, + 430, + 289 + ], + "score": 0.94, + "content": "\\exp \\bigl ( - \\frac { | | \\boldsymbol { a } - \\boldsymbol { a } _ { \\mathrm { c } } | | ^ { 2 } } { 2 \\sigma _ { g } ^ { 2 } } \\bigr )", + "type": "inline_equation" + }, + { + "bbox": [ + 431, + 266, + 505, + 282 + ], + "score": 1.0, + "content": "inside the region,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 287, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 106, + 287, + 133, + 300 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 289, + 156, + 299 + ], + "score": 0.88, + "content": "{ \\mathbf { } } a , a _ { \\mathrm { { c } } }", + "type": "inline_equation" + }, + { + "bbox": [ + 156, + 287, + 370, + 300 + ], + "score": 1.0, + "content": "denote any pixel and the center point, respectively.", + "type": "text" + }, + { + "bbox": [ + 370, + 290, + 382, + 299 + ], + "score": 0.83, + "content": "\\sigma _ { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 287, + 505, + 300 + ], + "score": 1.0, + "content": "is the hyper-parameter which", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 297, + 506, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 506, + 311 + ], + "score": 1.0, + "content": "is set as 1 empirically. In the training stage, FPN (Lin et al., 2017) is used for multi-level feature", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 309, + 354, + 321 + ], + "spans": [ + { + "bbox": [ + 106, + 309, + 354, + 321 + ], + "score": 1.0, + "content": "fusion. LCCD is optimized using the MSE loss in each point:", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15, + "bbox_fs": [ + 102, + 223, + 507, + 321 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 199, + 324, + 410, + 353 + ], + "lines": [ + { + "bbox": [ + 199, + 324, + 410, + 353 + ], + "spans": [ + { + "bbox": [ + 199, + 324, + 410, + 353 + ], + "score": 0.92, + "content": "{ \\cal L } _ { \\mathrm { L C C D } } = \\sum _ { j \\in \\{ 1 , 2 \\} } \\sum _ { { \\bf { a } } \\in \\widetilde { { \\pmb x } } } \\mathrm { M S E } ( M _ { \\mathrm { L C C D } } ^ { j } ( { \\pmb a } ) , M _ { \\mathrm { L C C D } } ^ { j } ( { \\pmb a } ) ^ { ' } ) ,", + "type": "interline_equation", + "image_path": "949b6cc4924d36c2320f85c899cd367cdea3c3fb35cbfc206596dabb9032cf9e.jpg" + } + ] + } + ], + "index": 19.5, + "virtual_lines": [ + { + "bbox": [ + 199, + 324, + 410, + 338.5 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 199, + 338.5, + 410, + 353.0 + ], + "spans": [], + "index": 20 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 358, + 497, + 373 + ], + "lines": [ + { + "bbox": [ + 105, + 358, + 494, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 133, + 374 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 360, + 173, + 372 + ], + "score": 0.84, + "content": "\\mathrm { M S E } ( \\cdot , \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 358, + 318, + 374 + ], + "score": 1.0, + "content": "denotes the MSE loss function, and", + "type": "text" + }, + { + "bbox": [ + 318, + 358, + 363, + 373 + ], + "score": 0.93, + "content": "M _ { \\mathrm { L C C D } } ^ { j } ( \\pmb { a } ) ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 358, + 487, + 374 + ], + "score": 1.0, + "content": "0 is the prediction of each pixel", + "type": "text" + }, + { + "bbox": [ + 487, + 362, + 494, + 370 + ], + "score": 0.71, + "content": "^ { a }", + "type": "inline_equation" + } + ], + "index": 21 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 358, + 494, + 374 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 377, + 505, + 444 + ], + "lines": [ + { + "bbox": [ + 106, + 378, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 106, + 378, + 505, + 389 + ], + "score": 1.0, + "content": "CSPC is designed to recognize the shuffling pattern of a shuffled clip. As mentioned early, the eight", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 388, + 505, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 505, + 401 + ], + "score": 1.0, + "content": "shuffled clips in each mini-batch are created from the same raw clip and differ only in the relative", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "score": 1.0, + "content": "order of the top-2 LCCs along each of the three dimensions. There are thus eight permutations", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 411, + 505, + 422 + ], + "spans": [ + { + "bbox": [ + 106, + 411, + 505, + 422 + ], + "score": 1.0, + "content": "depending on the order (correct or reverse) in each dimension. Based on this understanding, CSPC", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 104, + 420, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 104, + 420, + 505, + 434 + ], + "score": 1.0, + "content": "is formulated as a multi-class classification task to recognize each shuffled clip into one of these", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 433, + 381, + 444 + ], + "spans": [ + { + "bbox": [ + 106, + 433, + 381, + 444 + ], + "score": 1.0, + "content": "eight classes, which is optimized using the Cross-Entropy (CE) loss:", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24.5, + "bbox_fs": [ + 104, + 378, + 505, + 444 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 220, + 447, + 390, + 477 + ], + "lines": [ + { + "bbox": [ + 220, + 447, + 390, + 477 + ], + "spans": [ + { + "bbox": [ + 220, + 447, + 390, + 477 + ], + "score": 0.94, + "content": "L _ { \\mathrm { C S P C } } = \\sum _ { i \\in \\{ 0 , 1 , . . . , 7 \\} } { \\bf C E } ( l _ { \\mathrm { C S P C } } [ i ] , l _ { \\mathrm { C S P C } } ^ { ' } [ i ] ) ,", + "type": "interline_equation", + "image_path": "48e20e210dbec32facf8e5632a608c134ac60fdde0191ac8ce01ea94d87dae04.jpg" + } + ] + } + ], + "index": 28.5, + "virtual_lines": [ + { + "bbox": [ + 220, + 447, + 390, + 462.0 + ], + "spans": [], + "index": 28 + }, + { + "bbox": [ + 220, + 462.0, + 390, + 477.0 + ], + "spans": [], + "index": 29 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 482, + 504, + 506 + ], + "lines": [ + { + "bbox": [ + 105, + 481, + 506, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 481, + 133, + 497 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 483, + 165, + 495 + ], + "score": 0.9, + "content": "\\operatorname { C E } ( \\cdot , \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 481, + 303, + 497 + ], + "score": 1.0, + "content": "denotes the CE loss function and", + "type": "text" + }, + { + "bbox": [ + 304, + 481, + 334, + 496 + ], + "score": 0.93, + "content": "l _ { \\mathrm { C S P C } } ^ { ' } [ i ]", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 481, + 457, + 497 + ], + "score": 1.0, + "content": "is the predicted class label of", + "type": "text" + }, + { + "bbox": [ + 457, + 484, + 461, + 493 + ], + "score": 0.79, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 481, + 506, + 497 + ], + "score": 1.0, + "content": "-th sample", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 494, + 245, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 245, + 506 + ], + "score": 1.0, + "content": "(shuffled clip) in each mini-batch.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 481, + 506, + 506 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 510, + 505, + 600 + ], + "lines": [ + { + "bbox": [ + 106, + 511, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 505, + 524 + ], + "score": 1.0, + "content": "The two tasks above emphasize on local spatiotemporal continuity understanding. In contrast,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 522, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 505, + 535 + ], + "score": 1.0, + "content": "CLSC leverages the contrastive loss to encourage global continuity understanding. In particular,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 533, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 506, + 545 + ], + "score": 1.0, + "content": "since the top-2 LCCs dominate the volume of a clip, it is safe to assume that if their relative order is", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 544, + 505, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 505, + 557 + ], + "score": 1.0, + "content": "correct in all three dimensions, the shuffled clip largely preserve continuity compared to the original", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 555, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 106, + 555, + 505, + 568 + ], + "score": 1.0, + "content": "clip, while all other 7 permutations feature large discontinuity in at least one dimension. We thus", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 566, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 333, + 578 + ], + "score": 1.0, + "content": "form a contrastive learning task with the original video", + "type": "text" + }, + { + "bbox": [ + 333, + 568, + 342, + 576 + ], + "score": 0.73, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 566, + 505, + 578 + ], + "score": 1.0, + "content": "and the most continuous shuffled video", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 107, + 577, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 107, + 578, + 117, + 588 + ], + "score": 0.87, + "content": "\\widetilde { \\pmb { x } } _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 118, + 578, + 208, + 590 + ], + "score": 1.0, + "content": "as a positive pair, and", + "type": "text" + }, + { + "bbox": [ + 209, + 579, + 217, + 587 + ], + "score": 0.79, + "content": "_ { \\textbf { \\em x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 578, + 267, + 590 + ], + "score": 1.0, + "content": "and the rest", + "type": "text" + }, + { + "bbox": [ + 267, + 577, + 279, + 589 + ], + "score": 0.84, + "content": "\\widetilde { \\pmb { x } } _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 577, + 310, + 589 + ], + "score": 0.7, + "content": "( j \\neq i )", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 578, + 505, + 590 + ], + "score": 1.0, + "content": ") as negative pairs. CLSC is optimized using the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 587, + 350, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 350, + 600 + ], + "score": 1.0, + "content": "e eNoise Contrastive Estimation (NCE) (Tian et al., 2020) loss:", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 511, + 506, + 600 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 154, + 603, + 456, + 632 + ], + "lines": [ + { + "bbox": [ + 154, + 603, + 456, + 632 + ], + "spans": [ + { + "bbox": [ + 154, + 603, + 456, + 632 + ], + "score": 0.92, + "content": "\\begin{array} { r } { L _ { \\mathrm { C L S C } } = - \\log \\frac { \\exp ( \\sin ( f ( \\pmb { x } ) , f ( \\widetilde { \\pmb { x } } _ { i } ) ) / \\tau ) } { \\exp ( \\sin ( f ( \\pmb { x } ) , f ( \\widetilde { \\pmb { x } } _ { i } ) ) / \\tau ) + \\sum _ { j } \\exp ( \\sin ( f ( \\pmb { x } ) , f ( \\widetilde { \\pmb { x } } _ { j } ) ) / \\tau ) } , } \\end{array}", + "type": "interline_equation", + "image_path": "eb953d201cb8d73386a8cee9aa86599758df0af996550c66f5ea9c315298fe77.jpg" + } + ] + } + ], + "index": 41, + "virtual_lines": [ + { + "bbox": [ + 154, + 603, + 456, + 612.6666666666666 + ], + "spans": [], + "index": 40 + }, + { + "bbox": [ + 154, + 612.6666666666666, + 456, + 622.3333333333333 + ], + "spans": [], + "index": 41 + }, + { + "bbox": [ + 154, + 622.3333333333333, + 456, + 631.9999999999999 + ], + "spans": [], + "index": 42 + } + ] + }, + { + "type": "list", + "bbox": [ + 105, + 636, + 503, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 636, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 133, + 651 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 638, + 166, + 650 + ], + "score": 0.91, + "content": "\\sin ( \\cdot , \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 636, + 284, + 651 + ], + "score": 1.0, + "content": "is defined by the dot product:", + "type": "text" + }, + { + "bbox": [ + 284, + 636, + 335, + 650 + ], + "score": 0.93, + "content": "f ( \\pmb { x } ) ^ { \\top } f ( \\widetilde { \\pmb { x } } _ { i } )", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 636, + 355, + 651 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 355, + 640, + 362, + 648 + ], + "score": 0.79, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 636, + 505, + 651 + ], + "score": 1.0, + "content": "is the temperature hyper-parameter.", + "type": "text" + } + ], + "index": 43, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 649, + 321, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 321, + 660 + ], + "score": 1.0, + "content": "Note that the non-local operator is not used in CLSC.", + "type": "text" + } + ], + "index": 44, + "is_list_start_line": true, + "is_list_end_line": true + } + ], + "index": 43.5, + "bbox_fs": [ + 105, + 636, + 505, + 660 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 665, + 505, + 735 + ], + "lines": [ + { + "bbox": [ + 106, + 666, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 505, + 677 + ], + "score": 1.0, + "content": "CCMR is similar to CLSC in that it also enforces global continuity understanding, but differs in", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "that it is a regression task aimed at predicting a global continuity measure. We consider two such", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 103, + 684, + 508, + 704 + ], + "spans": [ + { + "bbox": [ + 103, + 684, + 308, + 704 + ], + "score": 1.0, + "content": "measures. Since the total size of the top-2 LCCs", + "type": "text" + }, + { + "bbox": [ + 309, + 687, + 394, + 700 + ], + "score": 0.9, + "content": "\\{ c _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } } ( j ) : j = 1 , 2 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 394, + 684, + 508, + 704 + ], + "score": 1.0, + "content": "is a good indicator of how", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 318, + 712 + ], + "score": 1.0, + "content": "continuous a shuffle video clip is, the first measure", + "type": "text" + }, + { + "bbox": [ + 318, + 700, + 330, + 710 + ], + "score": 0.88, + "content": "l _ { l d }", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "directly measures the relative total size of", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 706, + 504, + 735 + ], + "spans": [ + { + "bbox": [ + 105, + 706, + 173, + 729 + ], + "score": 1.0, + "content": "the top-2 LCCs:", + "type": "text" + }, + { + "bbox": [ + 173, + 709, + 299, + 735 + ], + "score": 0.93, + "content": "l _ { l d } = \\frac { \\mathbf { v } ( { c } _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } } ( 1 ) ) + \\mathbf { v } ( { c } _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } } ( 2 ) ) } { \\mathbf { v } ( \\widetilde { \\pmb { x } } ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 299, + 706, + 330, + 729 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 330, + 716, + 346, + 728 + ], + "score": 0.87, + "content": "\\mathbf { v } ( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 706, + 504, + 729 + ], + "score": 1.0, + "content": "represents the volume of a clip/cuboid.", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 47, + "bbox_fs": [ + 103, + 666, + 508, + 735 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 81, + 505, + 151 + ], + "lines": [ + { + "bbox": [ + 107, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 107, + 81, + 192, + 96 + ], + "score": 1.0, + "content": "The second measure", + "type": "text" + }, + { + "bbox": [ + 192, + 81, + 211, + 95 + ], + "score": 0.91, + "content": "l _ { \\mathrm { h d } } ^ { \\mathrm { t / h / w } }", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 81, + 348, + 96 + ], + "score": 1.0, + "content": "examines the shuffling degree of", + "type": "text" + }, + { + "bbox": [ + 348, + 83, + 356, + 92 + ], + "score": 0.82, + "content": "\\widetilde { \\pmb x }", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "in each dimension, computed as the", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 233, + 114 + ], + "score": 1.0, + "content": "normalized hamming distance:", + "type": "text" + }, + { + "bbox": [ + 235, + 93, + 297, + 119 + ], + "score": 0.93, + "content": "\\frac { \\mathrm { h a m m i n g } ( \\widetilde { \\pmb { x } } ) } { N _ { c } ( N _ { c } - 1 ) / 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 99, + 367, + 113 + ], + "score": 1.0, + "content": "where hamming", + "type": "text" + }, + { + "bbox": [ + 368, + 100, + 379, + 112 + ], + "score": 0.56, + "content": "( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 99, + 505, + 113 + ], + "score": 1.0, + "content": "denotes the hamming distance", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 118, + 504, + 130 + ], + "spans": [ + { + "bbox": [ + 106, + 118, + 433, + 130 + ], + "score": 1.0, + "content": "in each dimension between the original piece sequence and the permuted one, and", + "type": "text" + }, + { + "bbox": [ + 433, + 118, + 447, + 128 + ], + "score": 0.89, + "content": "N _ { c }", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 118, + 504, + 130 + ], + "score": 1.0, + "content": "represents the", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 126, + 506, + 142 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 278, + 142 + ], + "score": 1.0, + "content": "number of pieces in each dimension so that", + "type": "text" + }, + { + "bbox": [ + 279, + 128, + 335, + 140 + ], + "score": 0.93, + "content": "N _ { c } ( \\bar { N } _ { c } { - } 1 ) / 2", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 126, + 506, + 142 + ], + "score": 1.0, + "content": "indicates the maximum possible hamming", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 140, + 469, + 151 + ], + "spans": [ + { + "bbox": [ + 106, + 140, + 469, + 151 + ], + "score": 1.0, + "content": "distance in the dimension. CCMR is optimized using the Mean Squared Error (MSE) loss:", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2 + }, + { + "type": "interline_equation", + "bbox": [ + 207, + 154, + 402, + 170 + ], + "lines": [ + { + "bbox": [ + 207, + 154, + 402, + 170 + ], + "spans": [ + { + "bbox": [ + 207, + 154, + 402, + 170 + ], + "score": 0.91, + "content": "\\begin{array} { r } { L _ { \\mathrm { C C M R } } = \\mathbf { M S E } \\big ( \\big [ l _ { \\mathrm { l d } } , l _ { \\mathrm { h d } } ^ { \\mathrm { t } } , l _ { \\mathrm { h d } } ^ { \\mathrm { h } } , l _ { \\mathrm { h d } } ^ { \\mathrm { w } } \\big ] , \\big [ l _ { \\mathrm { l d } } ^ { ' } , l _ { \\mathrm { h d } } ^ { \\mathrm { t } ^ { \\prime } } , l _ { \\mathrm { h d } } ^ { \\mathrm { h } ^ { \\prime } } , l _ { \\mathrm { h d } } ^ { \\mathrm { w } ^ { \\prime } } \\big ] \\big ) , } \\end{array}", + "type": "interline_equation", + "image_path": "4767e40c1da86d5fa8565151bed879de55d0227d5a08c9c19370d0825a27f481.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 207, + 154, + 402, + 170 + ], + "spans": [], + "index": 5 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 173, + 317, + 189 + ], + "lines": [ + { + "bbox": [ + 104, + 171, + 320, + 192 + ], + "spans": [ + { + "bbox": [ + 104, + 171, + 133, + 192 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 173, + 189, + 189 + ], + "score": 0.93, + "content": "l _ { \\mathrm { l d } } ^ { ' } , l _ { \\mathrm { h d } } ^ { \\mathrm { t } ^ { \\prime } } , l _ { \\mathrm { h d } } ^ { \\mathrm { h } ^ { \\prime } } , l _ { \\mathrm { h d } } ^ { \\mathrm { w } ^ { \\prime } }", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 171, + 320, + 192 + ], + "score": 1.0, + "content": "are the prediction of the model.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "title", + "bbox": [ + 108, + 200, + 273, + 212 + ], + "lines": [ + { + "bbox": [ + 106, + 200, + 273, + 213 + ], + "spans": [ + { + "bbox": [ + 106, + 200, + 273, + 213 + ], + "score": 1.0, + "content": "3.4 OVERALL LEARNING OBJECTIVE", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 104, + 221, + 465, + 234 + ], + "lines": [ + { + "bbox": [ + 105, + 220, + 466, + 235 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 466, + 235 + ], + "score": 1.0, + "content": "Our entire CSJ framework is optimized end-to-end with the learning objective defined as:", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "interline_equation", + "bbox": [ + 202, + 237, + 407, + 250 + ], + "lines": [ + { + "bbox": [ + 202, + 237, + 407, + 250 + ], + "spans": [ + { + "bbox": [ + 202, + 237, + 407, + 250 + ], + "score": 0.89, + "content": "L = \\sigma _ { 1 } L _ { \\mathrm { L C C D } } + \\sigma _ { 2 } L _ { \\mathrm { C S P C } } + \\sigma _ { 3 } L _ { \\mathrm { C L S C } } + \\sigma _ { 4 } L _ { \\mathrm { C C M R } } ,", + "type": "interline_equation", + "image_path": "cfe22f00a9d2c9501eceed80a3a2982950d8de5d45231b7c6b4e07ca3e5da892.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 202, + 237, + 407, + 250 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 253, + 504, + 298 + ], + "lines": [ + { + "bbox": [ + 105, + 253, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 133, + 267 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 256, + 188, + 265 + ], + "score": 0.88, + "content": "\\sigma _ { 1 } , \\sigma _ { 2 } , \\sigma _ { 3 } , \\sigma _ { 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 253, + 505, + 267 + ], + "score": 1.0, + "content": "denote the weights for the four losses. We deploy the adaptive weighting mech-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 264, + 505, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 505, + 277 + ], + "score": 1.0, + "content": "anism (Kendall et al., 2018) to weight these tasks, and thus there is no free hyper-parameters to tune.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 275, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 505, + 289 + ], + "score": 1.0, + "content": "We also adopt curriculum learning (Bengio et al., 2009; Korbar et al., 2018) to train our network by", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 286, + 457, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 457, + 299 + ], + "score": 1.0, + "content": "shuffling clips from easy to hard. More details are presented in Appendix. A.1 and A.2.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11.5 + }, + { + "type": "title", + "bbox": [ + 108, + 313, + 200, + 326 + ], + "lines": [ + { + "bbox": [ + 105, + 312, + 201, + 328 + ], + "spans": [ + { + "bbox": [ + 105, + 312, + 201, + 328 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "title", + "bbox": [ + 108, + 338, + 243, + 349 + ], + "lines": [ + { + "bbox": [ + 105, + 336, + 244, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 244, + 351 + ], + "score": 1.0, + "content": "4.1 DATASETS AND SETTINGS", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 106, + 359, + 505, + 491 + ], + "lines": [ + { + "bbox": [ + 106, + 358, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 106, + 358, + 505, + 371 + ], + "score": 1.0, + "content": "We select three benchmark datasets for performance evaluation: UCF101 (Soomro et al.,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 369, + 506, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 369, + 506, + 384 + ], + "score": 1.0, + "content": "2012), HMDB51 (Kuehne et al., 2011), and Kinetics-400 (K400) (Kay et al., 2017), containing", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 380, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 505, + 394 + ], + "score": 1.0, + "content": "13K/7K/306K video clips from 101/51/400 action classes, respectively. In the self-supervised pre-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 392, + 505, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 505, + 404 + ], + "score": 1.0, + "content": "training stage, we utilize the first training split of UCF101/HMDB51 and the training split of K400", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 403, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 106, + 403, + 505, + 415 + ], + "score": 1.0, + "content": "without using their labels. As in Han et al. (2020), we adopt R2D3D as the backbone network, which", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 413, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 505, + 425 + ], + "score": 1.0, + "content": "is modified from R3D (Hara et al., 2018) with fewer parameters. By fine-tuning the pre-trained", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 425, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 505, + 437 + ], + "score": 1.0, + "content": "model, we can evaluate the SSL performance on a downstream task (i.e., action classification). Fol-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 435, + 506, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 506, + 448 + ], + "score": 1.0, + "content": "lowing Han et al. (2019); He et al. (2020), two evaluation protocols are used: comparisons against", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 447, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 505, + 459 + ], + "score": 1.0, + "content": "state-of-the-arts follow the more popular fully fine-tuning evaluation protocol, but ablation analysis", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 458, + 505, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 505, + 470 + ], + "score": 1.0, + "content": "takes both the linear evaluation and fully fine-tuning protocols. For the experiments on supervised", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 468, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 105, + 468, + 505, + 480 + ], + "score": 1.0, + "content": "learning, we report top-1 accuracy on the first test split of UCF101/HMDB51 as the standard (Han", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 480, + 388, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 388, + 492 + ], + "score": 1.0, + "content": "et al., 2020). More details of the datasets are provided in Appendix B.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 21.5 + }, + { + "type": "title", + "bbox": [ + 108, + 503, + 248, + 514 + ], + "lines": [ + { + "bbox": [ + 105, + 502, + 250, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 250, + 515 + ], + "score": 1.0, + "content": "4.2 IMPLEMENTATION DETAILS", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 106, + 523, + 505, + 655 + ], + "lines": [ + { + "bbox": [ + 106, + 523, + 506, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 506, + 536 + ], + "score": 1.0, + "content": "Raw videos in these datasets are decoded at a frame rate of 24-30 fps. From each raw video, we start", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 534, + 505, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 505, + 547 + ], + "score": 1.0, + "content": "from a randomly selected frame index and sample a consecutive 16-frame video clip with a temporal", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 387, + 558 + ], + "score": 1.0, + "content": "stride of 4. For data augmentation, we first resize the video frames to", + "type": "text" + }, + { + "bbox": [ + 387, + 545, + 426, + 556 + ], + "score": 0.89, + "content": "1 2 8 \\times 1 7 1", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 545, + 505, + 558 + ], + "score": 1.0, + "content": "pixels, from which", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 556, + 506, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 241, + 569 + ], + "score": 1.0, + "content": "we extract random crops of size", + "type": "text" + }, + { + "bbox": [ + 242, + 556, + 281, + 567 + ], + "score": 0.89, + "content": "1 1 2 \\times 1 1 2", + "type": "inline_equation" + }, + { + "bbox": [ + 281, + 556, + 506, + 569 + ], + "score": 1.0, + "content": "pixels. We also apply random horizontal flipping and", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 567, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 505, + 579 + ], + "score": 1.0, + "content": "random color jittering to the video frames during training. We exploit only the raw RGB video", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 578, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 104, + 578, + 506, + 592 + ], + "score": 1.0, + "content": "frames as input, and do not leverage optical flow or other auxiliary signals for self-supervised pre-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 588, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 590, + 359, + 601 + ], + "score": 1.0, + "content": "training. We adopt the Adam optimizer with a weight decay of", + "type": "text" + }, + { + "bbox": [ + 360, + 588, + 381, + 599 + ], + "score": 0.9, + "content": "1 0 ^ { - 3 }", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 590, + 505, + 601 + ], + "score": 1.0, + "content": "and a batch size of 8 per GPU", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 599, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 465, + 613 + ], + "score": 1.0, + "content": "(with a total of 32 GPUs). We deploy cosine annealing learning rate with an initial value of", + "type": "text" + }, + { + "bbox": [ + 466, + 600, + 487, + 610 + ], + "score": 0.9, + "content": "\\bar { 1 } 0 ^ { - 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 599, + 506, + 613 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 610, + 505, + 624 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 289, + 624 + ], + "score": 1.0, + "content": "100 epochs. The jigsaw puzzle piece sizes of", + "type": "text" + }, + { + "bbox": [ + 290, + 611, + 335, + 623 + ], + "score": 0.93, + "content": "\\{ T , H , { \\bar { W } } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 610, + 424, + 624 + ], + "score": 1.0, + "content": "dimensions are set as", + "type": "text" + }, + { + "bbox": [ + 424, + 612, + 449, + 622 + ], + "score": 0.27, + "content": "1 , 4 , 4", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 610, + 505, + 624 + ], + "score": 1.0, + "content": ", respectively.", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 621, + 506, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 115, + 635 + ], + "score": 1.0, + "content": "A", + "type": "text" + }, + { + "bbox": [ + 116, + 622, + 172, + 633 + ], + "score": 0.88, + "content": "1 6 \\times 1 1 2 \\times 1 1 2", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 621, + 268, + 635 + ], + "score": 1.0, + "content": "video clip thus contains", + "type": "text" + }, + { + "bbox": [ + 268, + 623, + 315, + 633 + ], + "score": 0.9, + "content": "1 6 \\times 2 8 \\times 2 8", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 621, + 506, + 635 + ], + "score": 1.0, + "content": "pieces. We set the temperature hyper-parameter", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 633, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 113, + 643 + ], + "score": 0.73, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 633, + 505, + 645 + ], + "score": 1.0, + "content": "to 0.07. A dropout of 0.5 is applied to the final layer of each task. More implementation details of", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 643, + 388, + 655 + ], + "spans": [ + { + "bbox": [ + 106, + 643, + 388, + 655 + ], + "score": 1.0, + "content": "the fine-tuning and test evaluation stages can be found in Appendix B.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 34.5 + }, + { + "type": "title", + "bbox": [ + 107, + 667, + 198, + 678 + ], + "lines": [ + { + "bbox": [ + 105, + 666, + 199, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 199, + 680 + ], + "score": 1.0, + "content": "4.3 MAIN RESULTS", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "Comparison in Action Recognition A standard way to evaluate a self-supervised video represen-", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "tation learning model is to use it to initialize an action recognition model on a small dataset. Specif-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "ically, after self-supervised pre-training on UCF101/HMDB51/K400, we exploit the learned back-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 721, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 505, + 732 + ], + "score": 1.0, + "content": "bone for fully fine-tuning on UCF101 and HMDB51, following Han et al. (2020); Wang et al. (2020).", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43.5 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 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": "text", + "bbox": [ + 106, + 81, + 505, + 151 + ], + "lines": [ + { + "bbox": [ + 107, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 107, + 81, + 192, + 96 + ], + "score": 1.0, + "content": "The second measure", + "type": "text" + }, + { + "bbox": [ + 192, + 81, + 211, + 95 + ], + "score": 0.91, + "content": "l _ { \\mathrm { h d } } ^ { \\mathrm { t / h / w } }", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 81, + 348, + 96 + ], + "score": 1.0, + "content": "examines the shuffling degree of", + "type": "text" + }, + { + "bbox": [ + 348, + 83, + 356, + 92 + ], + "score": 0.82, + "content": "\\widetilde { \\pmb x }", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "in each dimension, computed as the", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 233, + 114 + ], + "score": 1.0, + "content": "normalized hamming distance:", + "type": "text" + }, + { + "bbox": [ + 235, + 93, + 297, + 119 + ], + "score": 0.93, + "content": "\\frac { \\mathrm { h a m m i n g } ( \\widetilde { \\pmb { x } } ) } { N _ { c } ( N _ { c } - 1 ) / 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 99, + 367, + 113 + ], + "score": 1.0, + "content": "where hamming", + "type": "text" + }, + { + "bbox": [ + 368, + 100, + 379, + 112 + ], + "score": 0.56, + "content": "( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 99, + 505, + 113 + ], + "score": 1.0, + "content": "denotes the hamming distance", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 118, + 504, + 130 + ], + "spans": [ + { + "bbox": [ + 106, + 118, + 433, + 130 + ], + "score": 1.0, + "content": "in each dimension between the original piece sequence and the permuted one, and", + "type": "text" + }, + { + "bbox": [ + 433, + 118, + 447, + 128 + ], + "score": 0.89, + "content": "N _ { c }", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 118, + 504, + 130 + ], + "score": 1.0, + "content": "represents the", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 126, + 506, + 142 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 278, + 142 + ], + "score": 1.0, + "content": "number of pieces in each dimension so that", + "type": "text" + }, + { + "bbox": [ + 279, + 128, + 335, + 140 + ], + "score": 0.93, + "content": "N _ { c } ( \\bar { N } _ { c } { - } 1 ) / 2", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 126, + 506, + 142 + ], + "score": 1.0, + "content": "indicates the maximum possible hamming", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 140, + 469, + 151 + ], + "spans": [ + { + "bbox": [ + 106, + 140, + 469, + 151 + ], + "score": 1.0, + "content": "distance in the dimension. CCMR is optimized using the Mean Squared Error (MSE) loss:", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2, + "bbox_fs": [ + 105, + 81, + 506, + 151 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 207, + 154, + 402, + 170 + ], + "lines": [ + { + "bbox": [ + 207, + 154, + 402, + 170 + ], + "spans": [ + { + "bbox": [ + 207, + 154, + 402, + 170 + ], + "score": 0.91, + "content": "\\begin{array} { r } { L _ { \\mathrm { C C M R } } = \\mathbf { M S E } \\big ( \\big [ l _ { \\mathrm { l d } } , l _ { \\mathrm { h d } } ^ { \\mathrm { t } } , l _ { \\mathrm { h d } } ^ { \\mathrm { h } } , l _ { \\mathrm { h d } } ^ { \\mathrm { w } } \\big ] , \\big [ l _ { \\mathrm { l d } } ^ { ' } , l _ { \\mathrm { h d } } ^ { \\mathrm { t } ^ { \\prime } } , l _ { \\mathrm { h d } } ^ { \\mathrm { h } ^ { \\prime } } , l _ { \\mathrm { h d } } ^ { \\mathrm { w } ^ { \\prime } } \\big ] \\big ) , } \\end{array}", + "type": "interline_equation", + "image_path": "4767e40c1da86d5fa8565151bed879de55d0227d5a08c9c19370d0825a27f481.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 207, + 154, + 402, + 170 + ], + "spans": [], + "index": 5 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 173, + 317, + 189 + ], + "lines": [ + { + "bbox": [ + 104, + 171, + 320, + 192 + ], + "spans": [ + { + "bbox": [ + 104, + 171, + 133, + 192 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 173, + 189, + 189 + ], + "score": 0.93, + "content": "l _ { \\mathrm { l d } } ^ { ' } , l _ { \\mathrm { h d } } ^ { \\mathrm { t } ^ { \\prime } } , l _ { \\mathrm { h d } } ^ { \\mathrm { h } ^ { \\prime } } , l _ { \\mathrm { h d } } ^ { \\mathrm { w } ^ { \\prime } }", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 171, + 320, + 192 + ], + "score": 1.0, + "content": "are the prediction of the model.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6, + "bbox_fs": [ + 104, + 171, + 320, + 192 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 200, + 273, + 212 + ], + "lines": [ + { + "bbox": [ + 106, + 200, + 273, + 213 + ], + "spans": [ + { + "bbox": [ + 106, + 200, + 273, + 213 + ], + "score": 1.0, + "content": "3.4 OVERALL LEARNING OBJECTIVE", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 104, + 221, + 465, + 234 + ], + "lines": [ + { + "bbox": [ + 105, + 220, + 466, + 235 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 466, + 235 + ], + "score": 1.0, + "content": "Our entire CSJ framework is optimized end-to-end with the learning objective defined as:", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 220, + 466, + 235 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 202, + 237, + 407, + 250 + ], + "lines": [ + { + "bbox": [ + 202, + 237, + 407, + 250 + ], + "spans": [ + { + "bbox": [ + 202, + 237, + 407, + 250 + ], + "score": 0.89, + "content": "L = \\sigma _ { 1 } L _ { \\mathrm { L C C D } } + \\sigma _ { 2 } L _ { \\mathrm { C S P C } } + \\sigma _ { 3 } L _ { \\mathrm { C L S C } } + \\sigma _ { 4 } L _ { \\mathrm { C C M R } } ,", + "type": "interline_equation", + "image_path": "cfe22f00a9d2c9501eceed80a3a2982950d8de5d45231b7c6b4e07ca3e5da892.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 202, + 237, + 407, + 250 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 253, + 504, + 298 + ], + "lines": [ + { + "bbox": [ + 105, + 253, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 133, + 267 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 256, + 188, + 265 + ], + "score": 0.88, + "content": "\\sigma _ { 1 } , \\sigma _ { 2 } , \\sigma _ { 3 } , \\sigma _ { 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 253, + 505, + 267 + ], + "score": 1.0, + "content": "denote the weights for the four losses. We deploy the adaptive weighting mech-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 264, + 505, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 505, + 277 + ], + "score": 1.0, + "content": "anism (Kendall et al., 2018) to weight these tasks, and thus there is no free hyper-parameters to tune.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 275, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 505, + 289 + ], + "score": 1.0, + "content": "We also adopt curriculum learning (Bengio et al., 2009; Korbar et al., 2018) to train our network by", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 286, + 457, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 457, + 299 + ], + "score": 1.0, + "content": "shuffling clips from easy to hard. More details are presented in Appendix. A.1 and A.2.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 253, + 505, + 299 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 313, + 200, + 326 + ], + "lines": [ + { + "bbox": [ + 105, + 312, + 201, + 328 + ], + "spans": [ + { + "bbox": [ + 105, + 312, + 201, + 328 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "title", + "bbox": [ + 108, + 338, + 243, + 349 + ], + "lines": [ + { + "bbox": [ + 105, + 336, + 244, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 244, + 351 + ], + "score": 1.0, + "content": "4.1 DATASETS AND SETTINGS", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 106, + 359, + 505, + 491 + ], + "lines": [ + { + "bbox": [ + 106, + 358, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 106, + 358, + 505, + 371 + ], + "score": 1.0, + "content": "We select three benchmark datasets for performance evaluation: UCF101 (Soomro et al.,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 369, + 506, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 369, + 506, + 384 + ], + "score": 1.0, + "content": "2012), HMDB51 (Kuehne et al., 2011), and Kinetics-400 (K400) (Kay et al., 2017), containing", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 380, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 505, + 394 + ], + "score": 1.0, + "content": "13K/7K/306K video clips from 101/51/400 action classes, respectively. In the self-supervised pre-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 392, + 505, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 505, + 404 + ], + "score": 1.0, + "content": "training stage, we utilize the first training split of UCF101/HMDB51 and the training split of K400", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 403, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 106, + 403, + 505, + 415 + ], + "score": 1.0, + "content": "without using their labels. As in Han et al. (2020), we adopt R2D3D as the backbone network, which", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 413, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 505, + 425 + ], + "score": 1.0, + "content": "is modified from R3D (Hara et al., 2018) with fewer parameters. By fine-tuning the pre-trained", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 425, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 505, + 437 + ], + "score": 1.0, + "content": "model, we can evaluate the SSL performance on a downstream task (i.e., action classification). Fol-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 435, + 506, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 506, + 448 + ], + "score": 1.0, + "content": "lowing Han et al. (2019); He et al. (2020), two evaluation protocols are used: comparisons against", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 447, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 505, + 459 + ], + "score": 1.0, + "content": "state-of-the-arts follow the more popular fully fine-tuning evaluation protocol, but ablation analysis", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 458, + 505, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 505, + 470 + ], + "score": 1.0, + "content": "takes both the linear evaluation and fully fine-tuning protocols. For the experiments on supervised", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 468, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 105, + 468, + 505, + 480 + ], + "score": 1.0, + "content": "learning, we report top-1 accuracy on the first test split of UCF101/HMDB51 as the standard (Han", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 480, + 388, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 388, + 492 + ], + "score": 1.0, + "content": "et al., 2020). More details of the datasets are provided in Appendix B.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 358, + 506, + 492 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 503, + 248, + 514 + ], + "lines": [ + { + "bbox": [ + 105, + 502, + 250, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 250, + 515 + ], + "score": 1.0, + "content": "4.2 IMPLEMENTATION DETAILS", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 106, + 523, + 505, + 655 + ], + "lines": [ + { + "bbox": [ + 106, + 523, + 506, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 506, + 536 + ], + "score": 1.0, + "content": "Raw videos in these datasets are decoded at a frame rate of 24-30 fps. From each raw video, we start", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 534, + 505, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 505, + 547 + ], + "score": 1.0, + "content": "from a randomly selected frame index and sample a consecutive 16-frame video clip with a temporal", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 387, + 558 + ], + "score": 1.0, + "content": "stride of 4. For data augmentation, we first resize the video frames to", + "type": "text" + }, + { + "bbox": [ + 387, + 545, + 426, + 556 + ], + "score": 0.89, + "content": "1 2 8 \\times 1 7 1", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 545, + 505, + 558 + ], + "score": 1.0, + "content": "pixels, from which", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 556, + 506, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 241, + 569 + ], + "score": 1.0, + "content": "we extract random crops of size", + "type": "text" + }, + { + "bbox": [ + 242, + 556, + 281, + 567 + ], + "score": 0.89, + "content": "1 1 2 \\times 1 1 2", + "type": "inline_equation" + }, + { + "bbox": [ + 281, + 556, + 506, + 569 + ], + "score": 1.0, + "content": "pixels. We also apply random horizontal flipping and", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 567, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 505, + 579 + ], + "score": 1.0, + "content": "random color jittering to the video frames during training. We exploit only the raw RGB video", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 578, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 104, + 578, + 506, + 592 + ], + "score": 1.0, + "content": "frames as input, and do not leverage optical flow or other auxiliary signals for self-supervised pre-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 588, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 590, + 359, + 601 + ], + "score": 1.0, + "content": "training. We adopt the Adam optimizer with a weight decay of", + "type": "text" + }, + { + "bbox": [ + 360, + 588, + 381, + 599 + ], + "score": 0.9, + "content": "1 0 ^ { - 3 }", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 590, + 505, + 601 + ], + "score": 1.0, + "content": "and a batch size of 8 per GPU", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 599, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 465, + 613 + ], + "score": 1.0, + "content": "(with a total of 32 GPUs). We deploy cosine annealing learning rate with an initial value of", + "type": "text" + }, + { + "bbox": [ + 466, + 600, + 487, + 610 + ], + "score": 0.9, + "content": "\\bar { 1 } 0 ^ { - 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 599, + 506, + 613 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 610, + 505, + 624 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 289, + 624 + ], + "score": 1.0, + "content": "100 epochs. The jigsaw puzzle piece sizes of", + "type": "text" + }, + { + "bbox": [ + 290, + 611, + 335, + 623 + ], + "score": 0.93, + "content": "\\{ T , H , { \\bar { W } } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 610, + 424, + 624 + ], + "score": 1.0, + "content": "dimensions are set as", + "type": "text" + }, + { + "bbox": [ + 424, + 612, + 449, + 622 + ], + "score": 0.27, + "content": "1 , 4 , 4", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 610, + 505, + 624 + ], + "score": 1.0, + "content": ", respectively.", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 621, + 506, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 115, + 635 + ], + "score": 1.0, + "content": "A", + "type": "text" + }, + { + "bbox": [ + 116, + 622, + 172, + 633 + ], + "score": 0.88, + "content": "1 6 \\times 1 1 2 \\times 1 1 2", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 621, + 268, + 635 + ], + "score": 1.0, + "content": "video clip thus contains", + "type": "text" + }, + { + "bbox": [ + 268, + 623, + 315, + 633 + ], + "score": 0.9, + "content": "1 6 \\times 2 8 \\times 2 8", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 621, + 506, + 635 + ], + "score": 1.0, + "content": "pieces. We set the temperature hyper-parameter", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 633, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 113, + 643 + ], + "score": 0.73, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 633, + 505, + 645 + ], + "score": 1.0, + "content": "to 0.07. A dropout of 0.5 is applied to the final layer of each task. More implementation details of", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 643, + 388, + 655 + ], + "spans": [ + { + "bbox": [ + 106, + 643, + 388, + 655 + ], + "score": 1.0, + "content": "the fine-tuning and test evaluation stages can be found in Appendix B.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 34.5, + "bbox_fs": [ + 104, + 523, + 506, + 655 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 667, + 198, + 678 + ], + "lines": [ + { + "bbox": [ + 105, + 666, + 199, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 199, + 680 + ], + "score": 1.0, + "content": "4.3 MAIN RESULTS", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "Comparison in Action Recognition A standard way to evaluate a self-supervised video represen-", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "tation learning model is to use it to initialize an action recognition model on a small dataset. Specif-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "ically, after self-supervised pre-training on UCF101/HMDB51/K400, we exploit the learned back-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 721, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 505, + 732 + ], + "score": 1.0, + "content": "bone for fully fine-tuning on UCF101 and HMDB51, following Han et al. (2020); Wang et al. (2020).", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43.5, + "bbox_fs": [ + 105, + 687, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 107, + 133, + 506, + 351 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 89, + 505, + 133 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 89, + 505, + 101 + ], + "spans": [ + { + "bbox": [ + 105, + 89, + 406, + 101 + ], + "score": 1.0, + "content": "Table 1: Comparison to the state-of-the-art on UCF101(U) and HMDB51", + "type": "text" + }, + { + "bbox": [ + 406, + 90, + 419, + 100 + ], + "score": 0.25, + "content": "\\mathrm { ( H ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 420, + 89, + 505, + 101 + ], + "score": 1.0, + "content": ". All models are pre-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 100, + 504, + 112 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 257, + 111 + ], + "score": 1.0, + "content": "trained with the RGB modality only.", + "type": "text" + }, + { + "bbox": [ + 258, + 101, + 264, + 112 + ], + "score": 0.34, + "content": "\\dagger", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 100, + 455, + 111 + ], + "score": 1.0, + "content": ": Methods with temporal-only transformations.", + "type": "text" + }, + { + "bbox": [ + 456, + 101, + 462, + 112 + ], + "score": 0.59, + "content": "^ \\ddag", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 100, + 504, + 111 + ], + "score": 1.0, + "content": ": Methods", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "spans": [ + { + "bbox": [ + 106, + 111, + 300, + 123 + ], + "score": 1.0, + "content": "with both spatial and temporal transformations.", + "type": "text" + }, + { + "bbox": [ + 300, + 113, + 308, + 122 + ], + "score": 0.46, + "content": "* 1", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 111, + 505, + 123 + ], + "score": 1.0, + "content": ": Methods that leverage spatiotemporal represen-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 122, + 407, + 134 + ], + "spans": [ + { + "bbox": [ + 106, + 122, + 407, + 134 + ], + "score": 1.0, + "content": "tations. HT: HowTo100M. The underline represents the second-best result.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "table_body", + "bbox": [ + 107, + 133, + 506, + 351 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 133, + 506, + 351 + ], + "spans": [ + { + "bbox": [ + 107, + 133, + 506, + 351 + ], + "score": 0.984, + "html": "
MethodsBackbonePre-trained DatasetsInput size (T*H)UCF101HMDB51
CMC (ECCV'20) (Tian et al.,2020)C2DU155.3
Skip-Clip† (El-Nouby et al.,2019)R3D-18U/H16*11264.4一
VCOPt (CVPR'19) (Xu et al.,2019)R3D-18U/H16*11264.929.5
VCP† (AAAI'20) (Luo et al.,2020b)R3D-18U/H16*11266.031.5
PRPt (CVPR'20)(Yao et al.,2020)R3D-18U/H16*11266.529.7
MemDPC* (ECCV'20) (Han et al.,2020) CSJ*(ours)R2D3D-18U/H40*12869.2一
Video-Jigsaw* (WACV'19) (Ahsan et al.,2019)R2D3D-18U/H16*11270.436.0
Statisics*(CVPR'19) (Wang et al.,2019)C2D C3DK40025*22455.427.0
ST-Puzzle‡ (AAAI'19) (Kim et al.,2019)R3D-18K40016*11261.233.4
DPC*(ICCVW'19) (Han et al.,2019)R2D3D-18K40016*11263.933.7
SpeedNet (CVPR'20) (Benaim et al.,2020)K40040*12868.234.5
VIE*(CVPR'20) (Zhuang et al.,2020)I3DK40016*22466.743.7
Pace† (ECCV'20) (Wang et al.,2020)R3D-18K40016*11275.544.6
CSJ* (ours)R(2+1)D-18K40016*11277.136.6
R2D3D-18K40016*11276.246.7
MemDPC* (ECCV'20) (Han et al.,2020) CBT (Sun et al.,2019)R2D3D-34K40040*22478.141.2
CSJ* (ours)S3D R2D3D-34K600+HT K400一 16*22479.544.6
79.550.9
Upper Bound:Fully-SupervisedR3D-34K40016*22487.759.1
", + "type": "table", + "image_path": "1bff20829ec6efe1bcb747c6d0c5de7a41a48da0a5bf9690b0e99a23afd672cd.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 107, + 133, + 506, + 205.66666666666669 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 107, + 205.66666666666669, + 506, + 278.33333333333337 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 107, + 278.33333333333337, + 506, + 351.00000000000006 + ], + "spans": [], + "index": 6 + } + ] + } + ], + "index": 3.25 + }, + { + "type": "table", + "bbox": [ + 108, + 394, + 505, + 497 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 108, + 371, + 504, + 394 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 371, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 106, + 371, + 505, + 384 + ], + "score": 1.0, + "content": "Table 2: Comparison with state-of-the-art self-supervised learning methods for nearest neighbor", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 383, + 466, + 395 + ], + "spans": [ + { + "bbox": [ + 106, + 383, + 186, + 395 + ], + "score": 1.0, + "content": "video retrieval (top-", + "type": "text" + }, + { + "bbox": [ + 186, + 383, + 192, + 393 + ], + "score": 0.72, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 193, + 383, + 466, + 395 + ], + "score": 1.0, + "content": "recall) on UCF101. The underline represents the second-best result.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "table_body", + "bbox": [ + 108, + 394, + 505, + 497 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 108, + 394, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 108, + 394, + 505, + 497 + ], + "score": 0.98, + "html": "
MethodsBackboneTop1Top5Top10Top20Top50
VCOP (CVPR'19) (Xu et al., 2019)R3D-1814.130.340.051.166.5
VCP (AAAI'20) (Luo et al., 2020b)R3D-1818.633.642.553.568.1
SpeedNet (CVPR'20) (Benaim et al., 2020)S3D-G13.128.137.549.565.0
PRP (CVPR'2O) (Yao et al.,2020)R3D-1822.838.546.755.269.1
Pace (ECCV'2O) (Wang et al., 2020)R3D-1819.936.246.155.669.2
ERUV (Luo et al., 2020a)R3D-1821.435.243.853.168.3
MemDPC (ECCV'20) (Han et al., 2020)R2D3D-1820.240.452.464.71
CSJ (ours)R2D3D-1821.540.553.264.970.0
", + "type": "table", + "image_path": "31542e11bca3852486d9dd6bd1509dbb0b59e2823fb683df148f1e4d6b29aa32.jpg" + } + ] + } + ], + "index": 10, + "virtual_lines": [ + { + "bbox": [ + 108, + 394, + 505, + 428.3333333333333 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 108, + 428.3333333333333, + 505, + 462.66666666666663 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 108, + 462.66666666666663, + 505, + 496.99999999999994 + ], + "spans": [], + "index": 11 + } + ] + } + ], + "index": 8.75 + }, + { + "type": "text", + "bbox": [ + 107, + 519, + 505, + 662 + ], + "lines": [ + { + "bbox": [ + 106, + 519, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 106, + 519, + 505, + 533 + ], + "score": 1.0, + "content": "We consider one baseline: fully-supervised learning with pre-training on K400. Note that this base-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 531, + 505, + 542 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 505, + 542 + ], + "score": 1.0, + "content": "line is commonly regarded as the upper bound of self-supervised representation learning (Alwassel", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 542, + 504, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 504, + 554 + ], + "score": 1.0, + "content": "et al., 2019). From Table 1, we have the following observations: (1) Our CSJ achieves state-of-the-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 552, + 506, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 506, + 565 + ], + "score": 1.0, + "content": "art performance on both UCF101 and HMDB51. Particularly, with the backbone R2D3D-18 that", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 563, + 506, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 168, + 576 + ], + "score": 1.0, + "content": "is weaker than", + "type": "text" + }, + { + "bbox": [ + 168, + 564, + 219, + 575 + ], + "score": 0.82, + "content": "\\mathrm { R } ( 2 + 1 ) \\mathrm { D } { - } 1 8 ", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 563, + 506, + 576 + ], + "score": 1.0, + "content": ", our CSJ performs comparably w.r.t. Pace on UCF101 but achieves a", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 107, + 574, + 505, + 587 + ], + "spans": [ + { + "bbox": [ + 107, + 574, + 126, + 585 + ], + "score": 0.84, + "content": "10 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 574, + 505, + 587 + ], + "score": 1.0, + "content": "improvement over Pace on HMDB51. (2) By exploiting spatiotemporal transformations for", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 585, + 505, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 505, + 598 + ], + "score": 1.0, + "content": "self-supervised representation learning, our CSJ beats either methods with only temporal transfor-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 595, + 505, + 610 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 140, + 610 + ], + "score": 1.0, + "content": "mations", + "type": "text" + }, + { + "bbox": [ + 141, + 597, + 153, + 608 + ], + "score": 0.43, + "content": "( \\dag )", + "type": "inline_equation" + }, + { + "bbox": [ + 153, + 595, + 389, + 610 + ], + "score": 1.0, + "content": "or methods with both spatial and temporal transformations", + "type": "text" + }, + { + "bbox": [ + 390, + 597, + 401, + 608 + ], + "score": 0.61, + "content": "( \\ddagger )", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 595, + 505, + 610 + ], + "score": 1.0, + "content": ", as well as those learning", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 607, + 505, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 232, + 620 + ], + "score": 1.0, + "content": "spatiotemporal representations", + "type": "text" + }, + { + "bbox": [ + 232, + 608, + 245, + 618 + ], + "score": 0.69, + "content": "( \\ast )", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 607, + 505, + 620 + ], + "score": 1.0, + "content": "via only contrastive learning (w./o. spatiotemporal transforma-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 618, + 505, + 631 + ], + "spans": [ + { + "bbox": [ + 106, + 618, + 505, + 631 + ], + "score": 1.0, + "content": "tions). (3) Our CSJ also outperforms CBT (Sun et al., 2019), which used ten-times more massive", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 628, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 247, + 642 + ], + "score": 1.0, + "content": "datasets (K600 (Carreira et al., 20", + "type": "text" + }, + { + "bbox": [ + 247, + 630, + 276, + 640 + ], + "score": 0.26, + "content": " { \\left| 8 \\right. } + { \\mathrm { H } }", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 628, + 505, + 642 + ], + "score": 1.0, + "content": "owto100M (Miech et al., 2019)) and multiple modalities", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 639, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 130, + 653 + ], + "score": 1.0, + "content": "(RGB", + "type": "text" + }, + { + "bbox": [ + 131, + 641, + 137, + 650 + ], + "score": 0.41, + "content": "+ .", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 639, + 505, + 653 + ], + "score": 1.0, + "content": "Audio). (4) Our CSJ is the closest to the fully-supervised one (upper bound), validating its", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 650, + 354, + 665 + ], + "spans": [ + { + "bbox": [ + 105, + 650, + 354, + 665 + ], + "score": 1.0, + "content": "effectiveness in self-supervised video representation learning.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 677, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "Comparison in Video Retrieval We evaluate our CSJ method in the video retrieval task. Fol-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "lowing Xu et al. (2019), we extract each video clips’ embeddings with the pre-training model and", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 268, + 711 + ], + "score": 1.0, + "content": "use each clip in the test set to query the", + "type": "text" + }, + { + "bbox": [ + 268, + 699, + 275, + 709 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "nearest clips in the training set. The comparative results", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "in Table 2 show that our method outperforms all other self-supervised methods and achieves new", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "state-of-the-art in video retrieval on UCF101. Particularly, our method beats the latest competitor", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 107, + 133, + 506, + 351 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 89, + 505, + 133 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 89, + 505, + 101 + ], + "spans": [ + { + "bbox": [ + 105, + 89, + 406, + 101 + ], + "score": 1.0, + "content": "Table 1: Comparison to the state-of-the-art on UCF101(U) and HMDB51", + "type": "text" + }, + { + "bbox": [ + 406, + 90, + 419, + 100 + ], + "score": 0.25, + "content": "\\mathrm { ( H ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 420, + 89, + 505, + 101 + ], + "score": 1.0, + "content": ". All models are pre-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 100, + 504, + 112 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 257, + 111 + ], + "score": 1.0, + "content": "trained with the RGB modality only.", + "type": "text" + }, + { + "bbox": [ + 258, + 101, + 264, + 112 + ], + "score": 0.34, + "content": "\\dagger", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 100, + 455, + 111 + ], + "score": 1.0, + "content": ": Methods with temporal-only transformations.", + "type": "text" + }, + { + "bbox": [ + 456, + 101, + 462, + 112 + ], + "score": 0.59, + "content": "^ \\ddag", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 100, + 504, + 111 + ], + "score": 1.0, + "content": ": Methods", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "spans": [ + { + "bbox": [ + 106, + 111, + 300, + 123 + ], + "score": 1.0, + "content": "with both spatial and temporal transformations.", + "type": "text" + }, + { + "bbox": [ + 300, + 113, + 308, + 122 + ], + "score": 0.46, + "content": "* 1", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 111, + 505, + 123 + ], + "score": 1.0, + "content": ": Methods that leverage spatiotemporal represen-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 122, + 407, + 134 + ], + "spans": [ + { + "bbox": [ + 106, + 122, + 407, + 134 + ], + "score": 1.0, + "content": "tations. HT: HowTo100M. The underline represents the second-best result.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "table_body", + "bbox": [ + 107, + 133, + 506, + 351 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 133, + 506, + 351 + ], + "spans": [ + { + "bbox": [ + 107, + 133, + 506, + 351 + ], + "score": 0.984, + "html": "
MethodsBackbonePre-trained DatasetsInput size (T*H)UCF101HMDB51
CMC (ECCV'20) (Tian et al.,2020)C2DU155.3
Skip-Clip† (El-Nouby et al.,2019)R3D-18U/H16*11264.4一
VCOPt (CVPR'19) (Xu et al.,2019)R3D-18U/H16*11264.929.5
VCP† (AAAI'20) (Luo et al.,2020b)R3D-18U/H16*11266.031.5
PRPt (CVPR'20)(Yao et al.,2020)R3D-18U/H16*11266.529.7
MemDPC* (ECCV'20) (Han et al.,2020) CSJ*(ours)R2D3D-18U/H40*12869.2一
Video-Jigsaw* (WACV'19) (Ahsan et al.,2019)R2D3D-18U/H16*11270.436.0
Statisics*(CVPR'19) (Wang et al.,2019)C2D C3DK40025*22455.427.0
ST-Puzzle‡ (AAAI'19) (Kim et al.,2019)R3D-18K40016*11261.233.4
DPC*(ICCVW'19) (Han et al.,2019)R2D3D-18K40016*11263.933.7
SpeedNet (CVPR'20) (Benaim et al.,2020)K40040*12868.234.5
VIE*(CVPR'20) (Zhuang et al.,2020)I3DK40016*22466.743.7
Pace† (ECCV'20) (Wang et al.,2020)R3D-18K40016*11275.544.6
CSJ* (ours)R(2+1)D-18K40016*11277.136.6
R2D3D-18K40016*11276.246.7
MemDPC* (ECCV'20) (Han et al.,2020) CBT (Sun et al.,2019)R2D3D-34K40040*22478.141.2
CSJ* (ours)S3D R2D3D-34K600+HT K400一 16*22479.544.6
79.550.9
Upper Bound:Fully-SupervisedR3D-34K40016*22487.759.1
", + "type": "table", + "image_path": "1bff20829ec6efe1bcb747c6d0c5de7a41a48da0a5bf9690b0e99a23afd672cd.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 107, + 133, + 506, + 205.66666666666669 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 107, + 205.66666666666669, + 506, + 278.33333333333337 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 107, + 278.33333333333337, + 506, + 351.00000000000006 + ], + "spans": [], + "index": 6 + } + ] + } + ], + "index": 3.25 + }, + { + "type": "table", + "bbox": [ + 108, + 394, + 505, + 497 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 108, + 371, + 504, + 394 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 371, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 106, + 371, + 505, + 384 + ], + "score": 1.0, + "content": "Table 2: Comparison with state-of-the-art self-supervised learning methods for nearest neighbor", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 383, + 466, + 395 + ], + "spans": [ + { + "bbox": [ + 106, + 383, + 186, + 395 + ], + "score": 1.0, + "content": "video retrieval (top-", + "type": "text" + }, + { + "bbox": [ + 186, + 383, + 192, + 393 + ], + "score": 0.72, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 193, + 383, + 466, + 395 + ], + "score": 1.0, + "content": "recall) on UCF101. The underline represents the second-best result.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "table_body", + "bbox": [ + 108, + 394, + 505, + 497 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 108, + 394, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 108, + 394, + 505, + 497 + ], + "score": 0.98, + "html": "
MethodsBackboneTop1Top5Top10Top20Top50
VCOP (CVPR'19) (Xu et al., 2019)R3D-1814.130.340.051.166.5
VCP (AAAI'20) (Luo et al., 2020b)R3D-1818.633.642.553.568.1
SpeedNet (CVPR'20) (Benaim et al., 2020)S3D-G13.128.137.549.565.0
PRP (CVPR'2O) (Yao et al.,2020)R3D-1822.838.546.755.269.1
Pace (ECCV'2O) (Wang et al., 2020)R3D-1819.936.246.155.669.2
ERUV (Luo et al., 2020a)R3D-1821.435.243.853.168.3
MemDPC (ECCV'20) (Han et al., 2020)R2D3D-1820.240.452.464.71
CSJ (ours)R2D3D-1821.540.553.264.970.0
", + "type": "table", + "image_path": "31542e11bca3852486d9dd6bd1509dbb0b59e2823fb683df148f1e4d6b29aa32.jpg" + } + ] + } + ], + "index": 10, + "virtual_lines": [ + { + "bbox": [ + 108, + 394, + 505, + 428.3333333333333 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 108, + 428.3333333333333, + 505, + 462.66666666666663 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 108, + 462.66666666666663, + 505, + 496.99999999999994 + ], + "spans": [], + "index": 11 + } + ] + } + ], + "index": 8.75 + }, + { + "type": "text", + "bbox": [ + 107, + 519, + 505, + 662 + ], + "lines": [ + { + "bbox": [ + 106, + 519, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 106, + 519, + 505, + 533 + ], + "score": 1.0, + "content": "We consider one baseline: fully-supervised learning with pre-training on K400. Note that this base-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 531, + 505, + 542 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 505, + 542 + ], + "score": 1.0, + "content": "line is commonly regarded as the upper bound of self-supervised representation learning (Alwassel", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 542, + 504, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 504, + 554 + ], + "score": 1.0, + "content": "et al., 2019). From Table 1, we have the following observations: (1) Our CSJ achieves state-of-the-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 552, + 506, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 506, + 565 + ], + "score": 1.0, + "content": "art performance on both UCF101 and HMDB51. Particularly, with the backbone R2D3D-18 that", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 563, + 506, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 168, + 576 + ], + "score": 1.0, + "content": "is weaker than", + "type": "text" + }, + { + "bbox": [ + 168, + 564, + 219, + 575 + ], + "score": 0.82, + "content": "\\mathrm { R } ( 2 + 1 ) \\mathrm { D } { - } 1 8 ", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 563, + 506, + 576 + ], + "score": 1.0, + "content": ", our CSJ performs comparably w.r.t. Pace on UCF101 but achieves a", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 107, + 574, + 505, + 587 + ], + "spans": [ + { + "bbox": [ + 107, + 574, + 126, + 585 + ], + "score": 0.84, + "content": "10 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 574, + 505, + 587 + ], + "score": 1.0, + "content": "improvement over Pace on HMDB51. (2) By exploiting spatiotemporal transformations for", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 585, + 505, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 505, + 598 + ], + "score": 1.0, + "content": "self-supervised representation learning, our CSJ beats either methods with only temporal transfor-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 595, + 505, + 610 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 140, + 610 + ], + "score": 1.0, + "content": "mations", + "type": "text" + }, + { + "bbox": [ + 141, + 597, + 153, + 608 + ], + "score": 0.43, + "content": "( \\dag )", + "type": "inline_equation" + }, + { + "bbox": [ + 153, + 595, + 389, + 610 + ], + "score": 1.0, + "content": "or methods with both spatial and temporal transformations", + "type": "text" + }, + { + "bbox": [ + 390, + 597, + 401, + 608 + ], + "score": 0.61, + "content": "( \\ddagger )", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 595, + 505, + 610 + ], + "score": 1.0, + "content": ", as well as those learning", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 607, + 505, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 232, + 620 + ], + "score": 1.0, + "content": "spatiotemporal representations", + "type": "text" + }, + { + "bbox": [ + 232, + 608, + 245, + 618 + ], + "score": 0.69, + "content": "( \\ast )", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 607, + 505, + 620 + ], + "score": 1.0, + "content": "via only contrastive learning (w./o. spatiotemporal transforma-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 618, + 505, + 631 + ], + "spans": [ + { + "bbox": [ + 106, + 618, + 505, + 631 + ], + "score": 1.0, + "content": "tions). (3) Our CSJ also outperforms CBT (Sun et al., 2019), which used ten-times more massive", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 628, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 247, + 642 + ], + "score": 1.0, + "content": "datasets (K600 (Carreira et al., 20", + "type": "text" + }, + { + "bbox": [ + 247, + 630, + 276, + 640 + ], + "score": 0.26, + "content": " { \\left| 8 \\right. } + { \\mathrm { H } }", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 628, + 505, + 642 + ], + "score": 1.0, + "content": "owto100M (Miech et al., 2019)) and multiple modalities", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 639, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 130, + 653 + ], + "score": 1.0, + "content": "(RGB", + "type": "text" + }, + { + "bbox": [ + 131, + 641, + 137, + 650 + ], + "score": 0.41, + "content": "+ .", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 639, + 505, + 653 + ], + "score": 1.0, + "content": "Audio). (4) Our CSJ is the closest to the fully-supervised one (upper bound), validating its", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 650, + 354, + 665 + ], + "spans": [ + { + "bbox": [ + 105, + 650, + 354, + 665 + ], + "score": 1.0, + "content": "effectiveness in self-supervised video representation learning.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 519, + 506, + 665 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 677, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "Comparison in Video Retrieval We evaluate our CSJ method in the video retrieval task. Fol-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "lowing Xu et al. (2019), we extract each video clips’ embeddings with the pre-training model and", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 268, + 711 + ], + "score": 1.0, + "content": "use each clip in the test set to query the", + "type": "text" + }, + { + "bbox": [ + 268, + 699, + 275, + 709 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "nearest clips in the training set. The comparative results", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "in Table 2 show that our method outperforms all other self-supervised methods and achieves new", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "state-of-the-art in video retrieval on UCF101. Particularly, our method beats the latest competitor", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 677, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 146, + 113, + 465, + 240 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 89, + 502, + 111 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 89, + 504, + 102 + ], + "spans": [ + { + "bbox": [ + 106, + 89, + 504, + 102 + ], + "score": 1.0, + "content": "Table 3: Evaluation of pre-training tasks with the backbone R2D3D-18 under linear probe and fully", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 98, + 458, + 114 + ], + "spans": [ + { + "bbox": [ + 105, + 98, + 458, + 114 + ], + "score": 1.0, + "content": "fine-tuning protocols on UCF101. AW: Adaptive Weighting. CL: Curriculum Learning.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "table_body", + "bbox": [ + 146, + 113, + 465, + 240 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 146, + 113, + 465, + 240 + ], + "spans": [ + { + "bbox": [ + 146, + 113, + 465, + 240 + ], + "score": 0.812, + "html": "
TasksLinear ProbeFully Fine-tuning
Random Initialization8.363.6
LCCD21.867.8
CSPC22.668.1
CLSC18.968.1
CCMR22.768.1
CCMR+CSPC24.769.2
CCMR+CSPC+CLSC25.569.3
CCMR+CSPC+CLSC+LCCD27.969.5
CCMR+CSPC+CLSC+LCCD+AW28.270.0
CCMR+CSPC+CLSC+LCCD+AW+CL28.570.4
", + "type": "table", + "image_path": "aedbac6975b7a52eaf9df1c001520e62e0a2e157f7d308adadbac66bfea6305a.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 146, + 113, + 465, + 155.33333333333334 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 146, + 155.33333333333334, + 465, + 197.66666666666669 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 146, + 197.66666666666669, + 465, + 240.00000000000003 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 1.75 + }, + { + "type": "image", + "bbox": [ + 108, + 254, + 494, + 440 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 254, + 494, + 440 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 254, + 494, + 440 + ], + "spans": [ + { + "bbox": [ + 108, + 254, + 494, + 440 + ], + "score": 0.856, + "type": "image", + "image_path": "05879f14857b6a2ef744f82417429a2c36c8fe64aa824955368e18b252cb5f3a.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 108, + 254, + 494, + 316.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 108, + 316.0, + 494, + 378.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 108, + 378.0, + 494, + 440.0 + ], + "spans": [], + "index": 7 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 451, + 505, + 484 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 450, + 504, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 504, + 462 + ], + "score": 1.0, + "content": "Figure 3: Attention visualization of the last feature maps from the fine-tuned models on UCF101.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 460, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 505, + 475 + ], + "score": 1.0, + "content": "The first row denotes the raw frames from videos, and the last two rows correspond to fine-tuning", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 471, + 438, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 438, + 486 + ], + "score": 1.0, + "content": "from random initialization and our self-supervised pre-trained model, respectively.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 106, + 504, + 504, + 526 + ], + "lines": [ + { + "bbox": [ + 106, + 504, + 505, + 516 + ], + "spans": [ + { + "bbox": [ + 106, + 504, + 505, + 516 + ], + "score": 1.0, + "content": "PRP (Yao et al., 2020) on four out of five metrics. This indicates that our proposed CSJ is also", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 515, + 348, + 527 + ], + "spans": [ + { + "bbox": [ + 106, + 515, + 348, + 527 + ], + "score": 1.0, + "content": "effective for video representation learning in video retrieval.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + }, + { + "type": "title", + "bbox": [ + 108, + 543, + 235, + 554 + ], + "lines": [ + { + "bbox": [ + 105, + 542, + 236, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 236, + 556 + ], + "score": 1.0, + "content": "4.4 FURTHER EVALUATIONS", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 106, + 564, + 505, + 664 + ], + "lines": [ + { + "bbox": [ + 106, + 564, + 504, + 577 + ], + "spans": [ + { + "bbox": [ + 106, + 564, + 504, + 577 + ], + "score": 1.0, + "content": "Ablation Study We conduct ablative experiments to validate the effectiveness of four CSJ sur-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 576, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 505, + 588 + ], + "score": 1.0, + "content": "rogate tasks and two additional learning strategies. From Table 3, we can observe that: (1) Self-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 587, + 505, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 505, + 600 + ], + "score": 1.0, + "content": "supervised learning with each of the four tasks shows better generalization than fine-tuning the", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 597, + 506, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 506, + 611 + ], + "score": 1.0, + "content": "network from scratch (random initialization). (2) By training over all the four tasks jointly, we can", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 607, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 104, + 607, + 505, + 623 + ], + "score": 1.0, + "content": "achieve large performance gains (see ‘+LCCD’ vs. ‘CCMR’). (3) Each additional learning strategy", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 619, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 619, + 505, + 633 + ], + "score": 1.0, + "content": "(i.e., adaptive weighting or curriculum learning) leads to a small boost to the performance by 0.3-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 630, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 106, + 631, + 128, + 641 + ], + "score": 0.85, + "content": "0 . 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 630, + 400, + 644 + ], + "score": 1.0, + "content": ". (4) Our full model achieves a remarkable classification accuracy of", + "type": "text" + }, + { + "bbox": [ + 401, + 631, + 427, + 641 + ], + "score": 0.87, + "content": "7 0 . 4 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 630, + 505, + 644 + ], + "score": 1.0, + "content": ", demonstrating the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 640, + 506, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 506, + 655 + ], + "score": 1.0, + "content": "effectiveness of our proposed CSJ with only the RGB video stream (without additional optical flow,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 653, + 423, + 666 + ], + "spans": [ + { + "bbox": [ + 106, + 653, + 423, + 666 + ], + "score": 1.0, + "content": "audio, or text modalities). More ablative analysis can be found in Appendix D.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 677, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 676, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 676, + 505, + 690 + ], + "score": 1.0, + "content": "Visualization of Attention Maps Fig. 3 visualizes the attention map of the last feature maps from", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "score": 1.0, + "content": "two models fine-tuned on UCF101 with or without adopting our self-supervised pre-training. Since", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "each frame’s attention map involves four adjacent frames, it actually contains spatiotemporal seman-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 708, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 506, + 723 + ], + "score": 1.0, + "content": "tic features. We can see that our self-supervised pre-training with CSJ indeed helps to better capture", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 720, + 489, + 734 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 489, + 734 + ], + "score": 1.0, + "content": "meaningful spatiotemporal information and thus recognize the action categories more correctly.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 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": "table", + "bbox": [ + 146, + 113, + 465, + 240 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 89, + 502, + 111 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 89, + 504, + 102 + ], + "spans": [ + { + "bbox": [ + 106, + 89, + 504, + 102 + ], + "score": 1.0, + "content": "Table 3: Evaluation of pre-training tasks with the backbone R2D3D-18 under linear probe and fully", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 98, + 458, + 114 + ], + "spans": [ + { + "bbox": [ + 105, + 98, + 458, + 114 + ], + "score": 1.0, + "content": "fine-tuning protocols on UCF101. AW: Adaptive Weighting. CL: Curriculum Learning.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "table_body", + "bbox": [ + 146, + 113, + 465, + 240 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 146, + 113, + 465, + 240 + ], + "spans": [ + { + "bbox": [ + 146, + 113, + 465, + 240 + ], + "score": 0.812, + "html": "
TasksLinear ProbeFully Fine-tuning
Random Initialization8.363.6
LCCD21.867.8
CSPC22.668.1
CLSC18.968.1
CCMR22.768.1
CCMR+CSPC24.769.2
CCMR+CSPC+CLSC25.569.3
CCMR+CSPC+CLSC+LCCD27.969.5
CCMR+CSPC+CLSC+LCCD+AW28.270.0
CCMR+CSPC+CLSC+LCCD+AW+CL28.570.4
", + "type": "table", + "image_path": "aedbac6975b7a52eaf9df1c001520e62e0a2e157f7d308adadbac66bfea6305a.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 146, + 113, + 465, + 155.33333333333334 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 146, + 155.33333333333334, + 465, + 197.66666666666669 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 146, + 197.66666666666669, + 465, + 240.00000000000003 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 1.75 + }, + { + "type": "image", + "bbox": [ + 108, + 254, + 494, + 440 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 254, + 494, + 440 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 254, + 494, + 440 + ], + "spans": [ + { + "bbox": [ + 108, + 254, + 494, + 440 + ], + "score": 0.856, + "type": "image", + "image_path": "05879f14857b6a2ef744f82417429a2c36c8fe64aa824955368e18b252cb5f3a.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 108, + 254, + 494, + 316.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 108, + 316.0, + 494, + 378.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 108, + 378.0, + 494, + 440.0 + ], + "spans": [], + "index": 7 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 451, + 505, + 484 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 450, + 504, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 504, + 462 + ], + "score": 1.0, + "content": "Figure 3: Attention visualization of the last feature maps from the fine-tuned models on UCF101.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 460, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 505, + 475 + ], + "score": 1.0, + "content": "The first row denotes the raw frames from videos, and the last two rows correspond to fine-tuning", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 471, + 438, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 438, + 486 + ], + "score": 1.0, + "content": "from random initialization and our self-supervised pre-trained model, respectively.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 106, + 504, + 504, + 526 + ], + "lines": [ + { + "bbox": [ + 106, + 504, + 505, + 516 + ], + "spans": [ + { + "bbox": [ + 106, + 504, + 505, + 516 + ], + "score": 1.0, + "content": "PRP (Yao et al., 2020) on four out of five metrics. This indicates that our proposed CSJ is also", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 515, + 348, + 527 + ], + "spans": [ + { + "bbox": [ + 106, + 515, + 348, + 527 + ], + "score": 1.0, + "content": "effective for video representation learning in video retrieval.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5, + "bbox_fs": [ + 106, + 504, + 505, + 527 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 543, + 235, + 554 + ], + "lines": [ + { + "bbox": [ + 105, + 542, + 236, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 236, + 556 + ], + "score": 1.0, + "content": "4.4 FURTHER EVALUATIONS", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 106, + 564, + 505, + 664 + ], + "lines": [ + { + "bbox": [ + 106, + 564, + 504, + 577 + ], + "spans": [ + { + "bbox": [ + 106, + 564, + 504, + 577 + ], + "score": 1.0, + "content": "Ablation Study We conduct ablative experiments to validate the effectiveness of four CSJ sur-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 576, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 505, + 588 + ], + "score": 1.0, + "content": "rogate tasks and two additional learning strategies. From Table 3, we can observe that: (1) Self-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 587, + 505, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 505, + 600 + ], + "score": 1.0, + "content": "supervised learning with each of the four tasks shows better generalization than fine-tuning the", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 597, + 506, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 506, + 611 + ], + "score": 1.0, + "content": "network from scratch (random initialization). (2) By training over all the four tasks jointly, we can", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 607, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 104, + 607, + 505, + 623 + ], + "score": 1.0, + "content": "achieve large performance gains (see ‘+LCCD’ vs. ‘CCMR’). (3) Each additional learning strategy", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 619, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 619, + 505, + 633 + ], + "score": 1.0, + "content": "(i.e., adaptive weighting or curriculum learning) leads to a small boost to the performance by 0.3-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 630, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 106, + 631, + 128, + 641 + ], + "score": 0.85, + "content": "0 . 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 630, + 400, + 644 + ], + "score": 1.0, + "content": ". (4) Our full model achieves a remarkable classification accuracy of", + "type": "text" + }, + { + "bbox": [ + 401, + 631, + 427, + 641 + ], + "score": 0.87, + "content": "7 0 . 4 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 630, + 505, + 644 + ], + "score": 1.0, + "content": ", demonstrating the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 640, + 506, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 506, + 655 + ], + "score": 1.0, + "content": "effectiveness of our proposed CSJ with only the RGB video stream (without additional optical flow,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 653, + 423, + 666 + ], + "spans": [ + { + "bbox": [ + 106, + 653, + 423, + 666 + ], + "score": 1.0, + "content": "audio, or text modalities). More ablative analysis can be found in Appendix D.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 18, + "bbox_fs": [ + 104, + 564, + 506, + 666 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 677, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 676, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 676, + 505, + 690 + ], + "score": 1.0, + "content": "Visualization of Attention Maps Fig. 3 visualizes the attention map of the last feature maps from", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "score": 1.0, + "content": "two models fine-tuned on UCF101 with or without adopting our self-supervised pre-training. Since", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "each frame’s attention map involves four adjacent frames, it actually contains spatiotemporal seman-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 708, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 506, + 723 + ], + "score": 1.0, + "content": "tic features. We can see that our self-supervised pre-training with CSJ indeed helps to better capture", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 720, + 489, + 734 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 489, + 734 + ], + "score": 1.0, + "content": "meaningful spatiotemporal information and thus recognize the action categories more correctly.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 676, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 115, + 91, + 496, + 431 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 115, + 91, + 496, + 431 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 115, + 91, + 496, + 431 + ], + "spans": [ + { + "bbox": [ + 115, + 91, + 496, + 431 + ], + "score": 0.975, + "type": "image", + "image_path": "364822a46bd24076097579693c7a18c390267468a5a5de153032980e75a3b9f3.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 115, + 91, + 496, + 204.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 115, + 204.33333333333331, + 496, + 317.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 115, + 317.66666666666663, + 496, + 430.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 439, + 504, + 473 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 439, + 505, + 451 + ], + "spans": [ + { + "bbox": [ + 106, + 439, + 505, + 451 + ], + "score": 1.0, + "content": "Figure 4: Visualization of the LCCD predictions from the pre-trained models. Each row denotes the", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 450, + 505, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 192, + 463 + ], + "score": 1.0, + "content": "frames at time stamp", + "type": "text" + }, + { + "bbox": [ + 193, + 450, + 252, + 461 + ], + "score": 0.54, + "content": "= ( 0 , 4 , 8 , 1 2 )", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 450, + 505, + 463 + ], + "score": 1.0, + "content": "from one video clip. (a) raw frames (with color jittering); (b)", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 461, + 398, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 398, + 475 + ], + "score": 1.0, + "content": "shuffled frames; (c) the ground truth of LCCD; (d) network’s prediction.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 487, + 505, + 531 + ], + "lines": [ + { + "bbox": [ + 106, + 486, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 486, + 505, + 498 + ], + "score": 1.0, + "content": "Visualization of LCCD Predictions We also demonstrate the visualization of the LCCD predic-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 498, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 505, + 509 + ], + "score": 1.0, + "content": "tions from the pre-trained models in Fig. 4. We can observe that solving the LCCD task indeed", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 509, + 505, + 521 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 505, + 521 + ], + "score": 1.0, + "content": "enables the model to learn the locations of LCCs and understand spatiotemporal continuity, which", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 104, + 519, + 309, + 533 + ], + "spans": [ + { + "bbox": [ + 104, + 519, + 309, + 533 + ], + "score": 1.0, + "content": "is a key step towards video content understanding.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 7.5 + }, + { + "type": "title", + "bbox": [ + 108, + 547, + 195, + 560 + ], + "lines": [ + { + "bbox": [ + 104, + 546, + 197, + 564 + ], + "spans": [ + { + "bbox": [ + 104, + 546, + 197, + 564 + ], + "score": 1.0, + "content": "5 CONCLUSION", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 574, + 505, + 662 + ], + "lines": [ + { + "bbox": [ + 106, + 573, + 505, + 586 + ], + "spans": [ + { + "bbox": [ + 106, + 573, + 505, + 586 + ], + "score": 1.0, + "content": "We have introduced a novel self-supervised video representation learning method named Con-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 585, + 505, + 597 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 505, + 597 + ], + "score": 1.0, + "content": "strained Spatiotemporal Jigsaw (CSJ). By introducing constrained permutations, our proposed", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 595, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 505, + 609 + ], + "score": 1.0, + "content": "CSJ is the first to leverage spatiotemporal jigsaw in self-supervised video representation learning.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 606, + 505, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 505, + 619 + ], + "score": 1.0, + "content": "We also propose four surrogate tasks based on our constrained spatiotemporal jigsaws. They are", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 617, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 506, + 631 + ], + "score": 1.0, + "content": "designed to encourage a video representation model to understand the spatiotemporal continuity, a", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 629, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 505, + 641 + ], + "score": 1.0, + "content": "key building block towards video content analysis. Extensive experiments were carried out to val-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 639, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 505, + 651 + ], + "score": 1.0, + "content": "idate the effectiveness of each of the four CSJ tasks and also show that our approach achieves the", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 651, + 383, + 662 + ], + "spans": [ + { + "bbox": [ + 106, + 651, + 383, + 662 + ], + "score": 1.0, + "content": "state-of-the-art on two downstream tasks across various benchmarks.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14.5 + }, + { + "type": "title", + "bbox": [ + 107, + 680, + 175, + 691 + ], + "lines": [ + { + "bbox": [ + 106, + 679, + 176, + 693 + ], + "spans": [ + { + "bbox": [ + 106, + 679, + 176, + 693 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "Yazan Abu Farha and Juergen Gall. Ms-tcn: Multi-stage temporal convolutional network for action", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 115, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recogni-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 720, + 227, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 720, + 227, + 732 + ], + "score": 1.0, + "content": "tion, pp. 3575–3584, 2019.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 306, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 115, + 91, + 496, + 431 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 115, + 91, + 496, + 431 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 115, + 91, + 496, + 431 + ], + "spans": [ + { + "bbox": [ + 115, + 91, + 496, + 431 + ], + "score": 0.975, + "type": "image", + "image_path": "364822a46bd24076097579693c7a18c390267468a5a5de153032980e75a3b9f3.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 115, + 91, + 496, + 204.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 115, + 204.33333333333331, + 496, + 317.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 115, + 317.66666666666663, + 496, + 430.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 439, + 504, + 473 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 439, + 505, + 451 + ], + "spans": [ + { + "bbox": [ + 106, + 439, + 505, + 451 + ], + "score": 1.0, + "content": "Figure 4: Visualization of the LCCD predictions from the pre-trained models. Each row denotes the", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 450, + 505, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 192, + 463 + ], + "score": 1.0, + "content": "frames at time stamp", + "type": "text" + }, + { + "bbox": [ + 193, + 450, + 252, + 461 + ], + "score": 0.54, + "content": "= ( 0 , 4 , 8 , 1 2 )", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 450, + 505, + 463 + ], + "score": 1.0, + "content": "from one video clip. (a) raw frames (with color jittering); (b)", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 461, + 398, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 398, + 475 + ], + "score": 1.0, + "content": "shuffled frames; (c) the ground truth of LCCD; (d) network’s prediction.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 487, + 505, + 531 + ], + "lines": [ + { + "bbox": [ + 106, + 486, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 486, + 505, + 498 + ], + "score": 1.0, + "content": "Visualization of LCCD Predictions We also demonstrate the visualization of the LCCD predic-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 498, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 505, + 509 + ], + "score": 1.0, + "content": "tions from the pre-trained models in Fig. 4. We can observe that solving the LCCD task indeed", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 509, + 505, + 521 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 505, + 521 + ], + "score": 1.0, + "content": "enables the model to learn the locations of LCCs and understand spatiotemporal continuity, which", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 104, + 519, + 309, + 533 + ], + "spans": [ + { + "bbox": [ + 104, + 519, + 309, + 533 + ], + "score": 1.0, + "content": "is a key step towards video content understanding.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 7.5, + "bbox_fs": [ + 104, + 486, + 505, + 533 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 547, + 195, + 560 + ], + "lines": [ + { + "bbox": [ + 104, + 546, + 197, + 564 + ], + "spans": [ + { + "bbox": [ + 104, + 546, + 197, + 564 + ], + "score": 1.0, + "content": "5 CONCLUSION", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 574, + 505, + 662 + ], + "lines": [ + { + "bbox": [ + 106, + 573, + 505, + 586 + ], + "spans": [ + { + "bbox": [ + 106, + 573, + 505, + 586 + ], + "score": 1.0, + "content": "We have introduced a novel self-supervised video representation learning method named Con-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 585, + 505, + 597 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 505, + 597 + ], + "score": 1.0, + "content": "strained Spatiotemporal Jigsaw (CSJ). By introducing constrained permutations, our proposed", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 595, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 505, + 609 + ], + "score": 1.0, + "content": "CSJ is the first to leverage spatiotemporal jigsaw in self-supervised video representation learning.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 606, + 505, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 505, + 619 + ], + "score": 1.0, + "content": "We also propose four surrogate tasks based on our constrained spatiotemporal jigsaws. They are", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 617, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 506, + 631 + ], + "score": 1.0, + "content": "designed to encourage a video representation model to understand the spatiotemporal continuity, a", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 629, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 505, + 641 + ], + "score": 1.0, + "content": "key building block towards video content analysis. Extensive experiments were carried out to val-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 639, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 505, + 651 + ], + "score": 1.0, + "content": "idate the effectiveness of each of the four CSJ tasks and also show that our approach achieves the", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 651, + 383, + 662 + ], + "spans": [ + { + "bbox": [ + 106, + 651, + 383, + 662 + ], + "score": 1.0, + "content": "state-of-the-art on two downstream tasks across various benchmarks.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14.5, + "bbox_fs": [ + 105, + 573, + 506, + 662 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 680, + 175, + 691 + ], + "lines": [ + { + "bbox": [ + 106, + 679, + 176, + 693 + ], + "spans": [ + { + "bbox": [ + 106, + 679, + 176, + 693 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "Yazan Abu Farha and Juergen Gall. Ms-tcn: Multi-stage temporal convolutional network for action", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 115, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recogni-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 720, + 227, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 720, + 227, + 732 + ], + "score": 1.0, + "content": "tion, pp. 3575–3584, 2019.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21, + "bbox_fs": [ + 106, + 699, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 504, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 504, + 96 + ], + "score": 1.0, + "content": "Unaiza Ahsan, Rishi Madhok, and Irfan Essa. Video jigsaw: Unsupervised learning of spatiotem-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 94, + 410, + 106 + ], + "spans": [ + { + "bbox": [ + 115, + 94, + 410, + 106 + ], + "score": 1.0, + "content": "poral context for video action recognition. In WACV, pp. 179–189, 2019.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 108, + 112, + 504, + 146 + ], + "lines": [ + { + "bbox": [ + 106, + 112, + 505, + 124 + ], + "spans": [ + { + "bbox": [ + 106, + 112, + 505, + 124 + ], + "score": 1.0, + "content": "Humam Alwassel, Dhruv Mahajan, Lorenzo Torresani, Bernard Ghanem, and Du Tran. Self-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 123, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 115, + 123, + 505, + 136 + ], + "score": 1.0, + "content": "supervised learning by cross-modal audio-video clustering. arXiv preprint arXiv:1911.12667,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 114, + 133, + 143, + 147 + ], + "spans": [ + { + "bbox": [ + 114, + 133, + 143, + 147 + ], + "score": 1.0, + "content": "2019.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 106, + 153, + 504, + 187 + ], + "lines": [ + { + "bbox": [ + 106, + 153, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 153, + 505, + 167 + ], + "score": 1.0, + "content": "Sagie Benaim, Ariel Ephrat, Oran Lang, Inbar Mosseri, William T. Freeman, Michael Rubinstein,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 164, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 115, + 164, + 505, + 177 + ], + "score": 1.0, + "content": "Michal Irani, and Tali Dekel. Speednet: Learning the speediness in videos. In CVPR, pp. 9922–", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 175, + 167, + 187 + ], + "spans": [ + { + "bbox": [ + 115, + 175, + 167, + 187 + ], + "score": 1.0, + "content": "9931, 2020.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 194, + 504, + 217 + ], + "lines": [ + { + "bbox": [ + 105, + 193, + 506, + 208 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 506, + 208 + ], + "score": 1.0, + "content": "Yoshua Bengio, Jer´ ome Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In ˆ", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 116, + 205, + 221, + 218 + ], + "spans": [ + { + "bbox": [ + 116, + 205, + 221, + 218 + ], + "score": 1.0, + "content": "ICMLE, pp. 41–48, 2009.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 106, + 224, + 503, + 248 + ], + "lines": [ + { + "bbox": [ + 106, + 225, + 505, + 237 + ], + "spans": [ + { + "bbox": [ + 106, + 225, + 505, + 237 + ], + "score": 1.0, + "content": "Joao Carreira, Eric Noland, Andras Banki-Horvath, Chloe Hillier, and Andrew Zisserman. A short ˜", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 235, + 378, + 248 + ], + "spans": [ + { + "bbox": [ + 115, + 235, + 378, + 248 + ], + "score": 1.0, + "content": "note about kinetics-600. arXiv preprint arXiv:1808.01340, 2018.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 107, + 254, + 502, + 278 + ], + "lines": [ + { + "bbox": [ + 107, + 255, + 504, + 267 + ], + "spans": [ + { + "bbox": [ + 107, + 255, + 504, + 267 + ], + "score": 1.0, + "content": "Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 266, + 440, + 278 + ], + "spans": [ + { + "bbox": [ + 116, + 266, + 440, + 278 + ], + "score": 1.0, + "content": "contrastive learning of visual representations. In ICML, pp. 10709–10719, 2020.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 107, + 284, + 503, + 308 + ], + "lines": [ + { + "bbox": [ + 106, + 285, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 106, + 285, + 505, + 298 + ], + "score": 1.0, + "content": "Yue Chen, Yalong Bai, Wei Zhang, and Tao Mei. Destruction and construction learning for fine-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 296, + 358, + 309 + ], + "spans": [ + { + "bbox": [ + 115, + 296, + 358, + 309 + ], + "score": 1.0, + "content": "grained image recognition. In CVPR, pp. 5157–5166, 2019.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5 + }, + { + "type": "text", + "bbox": [ + 107, + 315, + 503, + 349 + ], + "lines": [ + { + "bbox": [ + 105, + 315, + 505, + 328 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 505, + 328 + ], + "score": 1.0, + "content": "Ruoyi Du, Dongliang Chang, Ayan Kumar Bhunia, Jiyang Xie, Yi-Zhe Song, Zhanyu Ma, and", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 114, + 325, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 114, + 325, + 505, + 340 + ], + "score": 1.0, + "content": "Jun Guo. Fine-grained visual classification via progressive multi-granularity training of jigsaw", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 338, + 315, + 350 + ], + "spans": [ + { + "bbox": [ + 115, + 338, + 315, + 350 + ], + "score": 1.0, + "content": "patches. arXiv preprint arXiv:2003.03836, 2020.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 106, + 356, + 503, + 390 + ], + "lines": [ + { + "bbox": [ + 106, + 356, + 504, + 368 + ], + "spans": [ + { + "bbox": [ + 106, + 356, + 504, + 368 + ], + "score": 1.0, + "content": "Alaaeldin El-Nouby, Shuangfei Zhai, Graham W. Taylor, and Joshua M. Susskind. Skip-clip: Self-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 368, + 505, + 380 + ], + "spans": [ + { + "bbox": [ + 116, + 368, + 505, + 380 + ], + "score": 1.0, + "content": "supervised spatiotemporal representation learning by future clip order ranking. arXiv preprint", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 378, + 220, + 390 + ], + "spans": [ + { + "bbox": [ + 115, + 378, + 220, + 390 + ], + "score": 1.0, + "content": "arXiv:1910.12770, 2019.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 397, + 502, + 420 + ], + "lines": [ + { + "bbox": [ + 105, + 395, + 504, + 412 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 504, + 412 + ], + "score": 1.0, + "content": "Basura Fernando, Hakan Bilen, Efstratios Gavves, and Stephen Gould. Self-supervised video rep-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 115, + 408, + 443, + 420 + ], + "spans": [ + { + "bbox": [ + 115, + 408, + 443, + 420 + ], + "score": 1.0, + "content": "resentation learning with odd-one-out networks. In CVPR, pp. 3636–3645, 2017.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 106, + 427, + 504, + 450 + ], + "lines": [ + { + "bbox": [ + 105, + 426, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 505, + 442 + ], + "score": 1.0, + "content": "Spyros Gidaris, Praveer Singh, and Nikos Komodakis. Unsupervised representation learning by", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 439, + 279, + 451 + ], + "spans": [ + { + "bbox": [ + 115, + 439, + 279, + 451 + ], + "score": 1.0, + "content": "predicting image rotations. ICLR, 2018.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 106, + 457, + 505, + 481 + ], + "lines": [ + { + "bbox": [ + 105, + 456, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 505, + 471 + ], + "score": 1.0, + "content": "Tengda Han, Weidi Xie, and Andrew Zisserman. Video representation learning by dense predictive", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 469, + 320, + 481 + ], + "spans": [ + { + "bbox": [ + 115, + 469, + 320, + 481 + ], + "score": 1.0, + "content": "coding. In ICCV Workshop, pp. 1483–1492, 2019.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 106, + 487, + 504, + 511 + ], + "lines": [ + { + "bbox": [ + 106, + 487, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 505, + 501 + ], + "score": 1.0, + "content": "Tengda Han, Weidi Xie, and Andrew Zisserman. Memory-augmented dense predictive coding for", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 117, + 499, + 304, + 510 + ], + "spans": [ + { + "bbox": [ + 117, + 499, + 304, + 510 + ], + "score": 1.0, + "content": "video representation learning. In ECCV, 2020.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 105, + 517, + 503, + 541 + ], + "lines": [ + { + "bbox": [ + 105, + 516, + 505, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 505, + 532 + ], + "score": 1.0, + "content": "Kensho Hara, Hirokatsu Kataoka, and Yutaka Satoh. Can spatiotemporal 3d cnns retrace the history", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 116, + 529, + 353, + 541 + ], + "spans": [ + { + "bbox": [ + 116, + 529, + 353, + 541 + ], + "score": 1.0, + "content": "of 2d cnns and imagenet? In CVPR, pp. 6546–6555, 2018.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5 + }, + { + "type": "text", + "bbox": [ + 105, + 547, + 504, + 571 + ], + "lines": [ + { + "bbox": [ + 106, + 547, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 106, + 547, + 505, + 560 + ], + "score": 1.0, + "content": "Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 559, + 426, + 571 + ], + "spans": [ + { + "bbox": [ + 116, + 559, + 426, + 571 + ], + "score": 1.0, + "content": "unsupervised visual representation learning. In CVPR, pp. 9729–9738, 2020.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 106, + 578, + 504, + 600 + ], + "lines": [ + { + "bbox": [ + 105, + 576, + 505, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 505, + 592 + ], + "score": 1.0, + "content": "Simon Jenni, Givi Meishvili, and Paolo Favaro. Learning video representations by transforming", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 588, + 207, + 601 + ], + "spans": [ + { + "bbox": [ + 115, + 588, + 207, + 601 + ], + "score": 1.0, + "content": "time. In ECCV, 2020.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5 + }, + { + "type": "text", + "bbox": [ + 105, + 608, + 504, + 631 + ], + "lines": [ + { + "bbox": [ + 105, + 607, + 506, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 506, + 622 + ], + "score": 1.0, + "content": "Longlong Jing, Xiaodong Yang, Jingen Liu, and Yingli Tian. Self-supervised spatiotemporal feature", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 619, + 433, + 631 + ], + "spans": [ + { + "bbox": [ + 115, + 619, + 433, + 631 + ], + "score": 1.0, + "content": "learning via video rotation prediction. arXiv preprint arXiv:1811.11387, 2018.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 109, + 637, + 504, + 672 + ], + "lines": [ + { + "bbox": [ + 106, + 636, + 505, + 652 + ], + "spans": [ + { + "bbox": [ + 106, + 636, + 505, + 652 + ], + "score": 1.0, + "content": "Will Kay, Joao Carreira, Karen Simonyan, Brian Zhang, Chloe Hillier, Sudheendra Vijaya- ˜", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 650, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 116, + 650, + 505, + 661 + ], + "score": 1.0, + "content": "narasimhan, Fabio Viola, Tim Green, Trevor Back, Paul Natsev, Mustafa Suleyman, and Andrew", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 659, + 493, + 672 + ], + "spans": [ + { + "bbox": [ + 115, + 659, + 493, + 672 + ], + "score": 1.0, + "content": "Zisserman. The kinetics human action video dataset. arXiv preprint arXiv:1705.06950, 2017.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 106, + 679, + 503, + 702 + ], + "lines": [ + { + "bbox": [ + 106, + 677, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 693 + ], + "score": 1.0, + "content": "Alex Kendall, Yarin Gal, and Roberto Cipolla. Multi-task learning using uncertainty to weigh losses", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 690, + 388, + 703 + ], + "spans": [ + { + "bbox": [ + 115, + 690, + 388, + 703 + ], + "score": 1.0, + "content": "for scene geometry and semantics. In CVPR, pp. 7482–7491, 2018.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + }, + { + "type": "text", + "bbox": [ + 108, + 709, + 502, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 504, + 722 + ], + "score": 1.0, + "content": "Dahun Kim, Donghyeon Cho, and In So Kweon. Self-supervised video representation learning with", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 721, + 349, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 349, + 732 + ], + "score": 1.0, + "content": "space-time cubic puzzles. In AAAI, pp. 8545–8552, 2019.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43.5 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "10", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 504, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 504, + 96 + ], + "score": 1.0, + "content": "Unaiza Ahsan, Rishi Madhok, and Irfan Essa. Video jigsaw: Unsupervised learning of spatiotem-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 94, + 410, + 106 + ], + "spans": [ + { + "bbox": [ + 115, + 94, + 410, + 106 + ], + "score": 1.0, + "content": "poral context for video action recognition. In WACV, pp. 179–189, 2019.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 106, + 81, + 504, + 106 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 112, + 504, + 146 + ], + "lines": [ + { + "bbox": [ + 106, + 112, + 505, + 124 + ], + "spans": [ + { + "bbox": [ + 106, + 112, + 505, + 124 + ], + "score": 1.0, + "content": "Humam Alwassel, Dhruv Mahajan, Lorenzo Torresani, Bernard Ghanem, and Du Tran. Self-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 123, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 115, + 123, + 505, + 136 + ], + "score": 1.0, + "content": "supervised learning by cross-modal audio-video clustering. arXiv preprint arXiv:1911.12667,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 114, + 133, + 143, + 147 + ], + "spans": [ + { + "bbox": [ + 114, + 133, + 143, + 147 + ], + "score": 1.0, + "content": "2019.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3, + "bbox_fs": [ + 106, + 112, + 505, + 147 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 153, + 504, + 187 + ], + "lines": [ + { + "bbox": [ + 106, + 153, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 153, + 505, + 167 + ], + "score": 1.0, + "content": "Sagie Benaim, Ariel Ephrat, Oran Lang, Inbar Mosseri, William T. Freeman, Michael Rubinstein,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 164, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 115, + 164, + 505, + 177 + ], + "score": 1.0, + "content": "Michal Irani, and Tali Dekel. Speednet: Learning the speediness in videos. In CVPR, pp. 9922–", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 175, + 167, + 187 + ], + "spans": [ + { + "bbox": [ + 115, + 175, + 167, + 187 + ], + "score": 1.0, + "content": "9931, 2020.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6, + "bbox_fs": [ + 106, + 153, + 505, + 187 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 194, + 504, + 217 + ], + "lines": [ + { + "bbox": [ + 105, + 193, + 506, + 208 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 506, + 208 + ], + "score": 1.0, + "content": "Yoshua Bengio, Jer´ ome Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In ˆ", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 116, + 205, + 221, + 218 + ], + "spans": [ + { + "bbox": [ + 116, + 205, + 221, + 218 + ], + "score": 1.0, + "content": "ICMLE, pp. 41–48, 2009.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 193, + 506, + 218 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 224, + 503, + 248 + ], + "lines": [ + { + "bbox": [ + 106, + 225, + 505, + 237 + ], + "spans": [ + { + "bbox": [ + 106, + 225, + 505, + 237 + ], + "score": 1.0, + "content": "Joao Carreira, Eric Noland, Andras Banki-Horvath, Chloe Hillier, and Andrew Zisserman. A short ˜", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 235, + 378, + 248 + ], + "spans": [ + { + "bbox": [ + 115, + 235, + 378, + 248 + ], + "score": 1.0, + "content": "note about kinetics-600. arXiv preprint arXiv:1808.01340, 2018.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5, + "bbox_fs": [ + 106, + 225, + 505, + 248 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 254, + 502, + 278 + ], + "lines": [ + { + "bbox": [ + 107, + 255, + 504, + 267 + ], + "spans": [ + { + "bbox": [ + 107, + 255, + 504, + 267 + ], + "score": 1.0, + "content": "Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 266, + 440, + 278 + ], + "spans": [ + { + "bbox": [ + 116, + 266, + 440, + 278 + ], + "score": 1.0, + "content": "contrastive learning of visual representations. In ICML, pp. 10709–10719, 2020.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5, + "bbox_fs": [ + 107, + 255, + 504, + 278 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 284, + 503, + 308 + ], + "lines": [ + { + "bbox": [ + 106, + 285, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 106, + 285, + 505, + 298 + ], + "score": 1.0, + "content": "Yue Chen, Yalong Bai, Wei Zhang, and Tao Mei. Destruction and construction learning for fine-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 296, + 358, + 309 + ], + "spans": [ + { + "bbox": [ + 115, + 296, + 358, + 309 + ], + "score": 1.0, + "content": "grained image recognition. In CVPR, pp. 5157–5166, 2019.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5, + "bbox_fs": [ + 106, + 285, + 505, + 309 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 315, + 503, + 349 + ], + "lines": [ + { + "bbox": [ + 105, + 315, + 505, + 328 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 505, + 328 + ], + "score": 1.0, + "content": "Ruoyi Du, Dongliang Chang, Ayan Kumar Bhunia, Jiyang Xie, Yi-Zhe Song, Zhanyu Ma, and", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 114, + 325, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 114, + 325, + 505, + 340 + ], + "score": 1.0, + "content": "Jun Guo. Fine-grained visual classification via progressive multi-granularity training of jigsaw", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 338, + 315, + 350 + ], + "spans": [ + { + "bbox": [ + 115, + 338, + 315, + 350 + ], + "score": 1.0, + "content": "patches. arXiv preprint arXiv:2003.03836, 2020.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 315, + 505, + 350 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 356, + 503, + 390 + ], + "lines": [ + { + "bbox": [ + 106, + 356, + 504, + 368 + ], + "spans": [ + { + "bbox": [ + 106, + 356, + 504, + 368 + ], + "score": 1.0, + "content": "Alaaeldin El-Nouby, Shuangfei Zhai, Graham W. Taylor, and Joshua M. Susskind. Skip-clip: Self-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 368, + 505, + 380 + ], + "spans": [ + { + "bbox": [ + 116, + 368, + 505, + 380 + ], + "score": 1.0, + "content": "supervised spatiotemporal representation learning by future clip order ranking. arXiv preprint", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 378, + 220, + 390 + ], + "spans": [ + { + "bbox": [ + 115, + 378, + 220, + 390 + ], + "score": 1.0, + "content": "arXiv:1910.12770, 2019.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20, + "bbox_fs": [ + 106, + 356, + 505, + 390 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 397, + 502, + 420 + ], + "lines": [ + { + "bbox": [ + 105, + 395, + 504, + 412 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 504, + 412 + ], + "score": 1.0, + "content": "Basura Fernando, Hakan Bilen, Efstratios Gavves, and Stephen Gould. Self-supervised video rep-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 115, + 408, + 443, + 420 + ], + "spans": [ + { + "bbox": [ + 115, + 408, + 443, + 420 + ], + "score": 1.0, + "content": "resentation learning with odd-one-out networks. In CVPR, pp. 3636–3645, 2017.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 395, + 504, + 420 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 427, + 504, + 450 + ], + "lines": [ + { + "bbox": [ + 105, + 426, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 505, + 442 + ], + "score": 1.0, + "content": "Spyros Gidaris, Praveer Singh, and Nikos Komodakis. Unsupervised representation learning by", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 439, + 279, + 451 + ], + "spans": [ + { + "bbox": [ + 115, + 439, + 279, + 451 + ], + "score": 1.0, + "content": "predicting image rotations. ICLR, 2018.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5, + "bbox_fs": [ + 105, + 426, + 505, + 451 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 457, + 505, + 481 + ], + "lines": [ + { + "bbox": [ + 105, + 456, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 505, + 471 + ], + "score": 1.0, + "content": "Tengda Han, Weidi Xie, and Andrew Zisserman. Video representation learning by dense predictive", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 469, + 320, + 481 + ], + "spans": [ + { + "bbox": [ + 115, + 469, + 320, + 481 + ], + "score": 1.0, + "content": "coding. In ICCV Workshop, pp. 1483–1492, 2019.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 456, + 505, + 481 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 487, + 504, + 511 + ], + "lines": [ + { + "bbox": [ + 106, + 487, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 505, + 501 + ], + "score": 1.0, + "content": "Tengda Han, Weidi Xie, and Andrew Zisserman. Memory-augmented dense predictive coding for", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 117, + 499, + 304, + 510 + ], + "spans": [ + { + "bbox": [ + 117, + 499, + 304, + 510 + ], + "score": 1.0, + "content": "video representation learning. In ECCV, 2020.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28.5, + "bbox_fs": [ + 106, + 487, + 505, + 510 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 517, + 503, + 541 + ], + "lines": [ + { + "bbox": [ + 105, + 516, + 505, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 505, + 532 + ], + "score": 1.0, + "content": "Kensho Hara, Hirokatsu Kataoka, and Yutaka Satoh. Can spatiotemporal 3d cnns retrace the history", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 116, + 529, + 353, + 541 + ], + "spans": [ + { + "bbox": [ + 116, + 529, + 353, + 541 + ], + "score": 1.0, + "content": "of 2d cnns and imagenet? In CVPR, pp. 6546–6555, 2018.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 516, + 505, + 541 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 547, + 504, + 571 + ], + "lines": [ + { + "bbox": [ + 106, + 547, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 106, + 547, + 505, + 560 + ], + "score": 1.0, + "content": "Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 559, + 426, + 571 + ], + "spans": [ + { + "bbox": [ + 116, + 559, + 426, + 571 + ], + "score": 1.0, + "content": "unsupervised visual representation learning. In CVPR, pp. 9729–9738, 2020.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5, + "bbox_fs": [ + 106, + 547, + 505, + 571 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 578, + 504, + 600 + ], + "lines": [ + { + "bbox": [ + 105, + 576, + 505, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 505, + 592 + ], + "score": 1.0, + "content": "Simon Jenni, Givi Meishvili, and Paolo Favaro. Learning video representations by transforming", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 588, + 207, + 601 + ], + "spans": [ + { + "bbox": [ + 115, + 588, + 207, + 601 + ], + "score": 1.0, + "content": "time. In ECCV, 2020.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 576, + 505, + 601 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 608, + 504, + 631 + ], + "lines": [ + { + "bbox": [ + 105, + 607, + 506, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 506, + 622 + ], + "score": 1.0, + "content": "Longlong Jing, Xiaodong Yang, Jingen Liu, and Yingli Tian. Self-supervised spatiotemporal feature", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 619, + 433, + 631 + ], + "spans": [ + { + "bbox": [ + 115, + 619, + 433, + 631 + ], + "score": 1.0, + "content": "learning via video rotation prediction. arXiv preprint arXiv:1811.11387, 2018.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 607, + 506, + 631 + ] + }, + { + "type": "text", + "bbox": [ + 109, + 637, + 504, + 672 + ], + "lines": [ + { + "bbox": [ + 106, + 636, + 505, + 652 + ], + "spans": [ + { + "bbox": [ + 106, + 636, + 505, + 652 + ], + "score": 1.0, + "content": "Will Kay, Joao Carreira, Karen Simonyan, Brian Zhang, Chloe Hillier, Sudheendra Vijaya- ˜", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 650, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 116, + 650, + 505, + 661 + ], + "score": 1.0, + "content": "narasimhan, Fabio Viola, Tim Green, Trevor Back, Paul Natsev, Mustafa Suleyman, and Andrew", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 659, + 493, + 672 + ], + "spans": [ + { + "bbox": [ + 115, + 659, + 493, + 672 + ], + "score": 1.0, + "content": "Zisserman. The kinetics human action video dataset. arXiv preprint arXiv:1705.06950, 2017.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39, + "bbox_fs": [ + 106, + 636, + 505, + 672 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 679, + 503, + 702 + ], + "lines": [ + { + "bbox": [ + 106, + 677, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 693 + ], + "score": 1.0, + "content": "Alex Kendall, Yarin Gal, and Roberto Cipolla. Multi-task learning using uncertainty to weigh losses", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 690, + 388, + 703 + ], + "spans": [ + { + "bbox": [ + 115, + 690, + 388, + 703 + ], + "score": 1.0, + "content": "for scene geometry and semantics. In CVPR, pp. 7482–7491, 2018.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5, + "bbox_fs": [ + 106, + 677, + 505, + 703 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 709, + 502, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 504, + 722 + ], + "score": 1.0, + "content": "Dahun Kim, Donghyeon Cho, and In So Kweon. Self-supervised video representation learning with", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 721, + 349, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 349, + 732 + ], + "score": 1.0, + "content": "space-time cubic puzzles. In AAAI, pp. 8545–8552, 2019.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43.5, + "bbox_fs": [ + 106, + 709, + 504, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 502, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 95 + ], + "score": 1.0, + "content": "Joshua Knights, Anthony Vanderkop, Daniel Ward, Olivia Mackenzie-Ross, and Peyman", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 92, + 504, + 107 + ], + "spans": [ + { + "bbox": [ + 115, + 92, + 504, + 107 + ], + "score": 1.0, + "content": "Moghadam. Temporally coherent embeddings for self-supervised video representation learning.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 116, + 104, + 279, + 116 + ], + "spans": [ + { + "bbox": [ + 116, + 104, + 279, + 116 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:2004.02753, 2020.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 104, + 122, + 504, + 146 + ], + "lines": [ + { + "bbox": [ + 106, + 123, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 106, + 123, + 505, + 136 + ], + "score": 1.0, + "content": "Bruno Korbar, Du Tran, and Lorenzo Torresani. Cooperative learning of audio and video models", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 116, + 133, + 410, + 146 + ], + "spans": [ + { + "bbox": [ + 116, + 133, + 410, + 146 + ], + "score": 1.0, + "content": "from self-supervised synchronization. In NeurIPS, pp. 7763–7774, 2018.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 152, + 504, + 186 + ], + "lines": [ + { + "bbox": [ + 105, + 151, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 505, + 165 + ], + "score": 1.0, + "content": "Hilde Kuehne, Ali Arslan, and Thomas Serre. The language of actions: Recovering the syntax and", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 116, + 163, + 506, + 177 + ], + "spans": [ + { + "bbox": [ + 116, + 163, + 506, + 177 + ], + "score": 1.0, + "content": "semantics of goal-directed human activities. In Proceedings of the IEEE conference on computer", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 174, + 322, + 187 + ], + "spans": [ + { + "bbox": [ + 116, + 174, + 322, + 187 + ], + "score": 1.0, + "content": "vision and pattern recognition, pp. 780–787, 2014.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 108, + 192, + 504, + 227 + ], + "lines": [ + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "score": 1.0, + "content": "Hildegard Kuehne, Hueihan Jhuang, Estibaliz Garrote, Tomaso Poggio, and Thomas Serre. Hmdb:", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 116, + 205, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 116, + 205, + 505, + 216 + ], + "score": 1.0, + "content": "A large video database for human motion recognition. In Proceedings of the IEEE International", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 117, + 215, + 339, + 227 + ], + "spans": [ + { + "bbox": [ + 117, + 215, + 339, + 227 + ], + "score": 1.0, + "content": "Conference on Computer Vision, pp. 2556–2563, 2011.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 106, + 233, + 502, + 257 + ], + "lines": [ + { + "bbox": [ + 105, + 232, + 504, + 247 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 504, + 247 + ], + "score": 1.0, + "content": "Hsin-Ying Lee, Jia-Bin Huang, Maneesh Singh, and Ming-Hsuan Yang. Unsupervised representa-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 115, + 245, + 378, + 256 + ], + "spans": [ + { + "bbox": [ + 115, + 245, + 378, + 256 + ], + "score": 1.0, + "content": "tion learning by sorting sequences. In ICCV, pp. 667–676, 2017.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 107, + 262, + 502, + 286 + ], + "lines": [ + { + "bbox": [ + 106, + 263, + 503, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 263, + 503, + 276 + ], + "score": 1.0, + "content": "Tsung-Yi Lin, Piotr Dollar, Ross Girshick, Kaiming He, Bharath Hariharan, and Serge Belongie.´", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 115, + 274, + 437, + 286 + ], + "spans": [ + { + "bbox": [ + 115, + 274, + 437, + 286 + ], + "score": 1.0, + "content": "Feature pyramid networks for object detection. In CVPR, pp. 2117–2125, 2017.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 106, + 292, + 504, + 316 + ], + "lines": [ + { + "bbox": [ + 106, + 292, + 505, + 305 + ], + "spans": [ + { + "bbox": [ + 106, + 292, + 505, + 305 + ], + "score": 1.0, + "content": "Dezhao Luo, Bo Fang, Yu Zhou, Yucan Zhou, Dayan Wu, and Weiping Wang. Exploring relations", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 303, + 483, + 316 + ], + "spans": [ + { + "bbox": [ + 115, + 303, + 483, + 316 + ], + "score": 1.0, + "content": "in untrimmed videos for self-supervised learning. arXiv preprint arXiv:2008.02711, 2020a.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 105, + 321, + 504, + 345 + ], + "lines": [ + { + "bbox": [ + 106, + 322, + 505, + 335 + ], + "spans": [ + { + "bbox": [ + 106, + 322, + 505, + 335 + ], + "score": 1.0, + "content": "Dezhao Luo, Chang Liu, Yu Zhou, Dongbao Yang, Can Ma, Qixiang Ye, and Weiping Wang. Video", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 116, + 333, + 430, + 345 + ], + "spans": [ + { + "bbox": [ + 116, + 333, + 430, + 345 + ], + "score": 1.0, + "content": "cloze procedure for self-supervised spatio-temporal learning. In AAAI, 2020b.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 107, + 351, + 504, + 385 + ], + "lines": [ + { + "bbox": [ + 106, + 351, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 505, + 364 + ], + "score": 1.0, + "content": "Antoine Miech, Dimitri Zhukov, Jean-Baptiste Alayrac, Makarand Tapaswi, Ivan Laptev, and Josef", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 362, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 115, + 362, + 505, + 375 + ], + "score": 1.0, + "content": "Sivic. Howto100m: Learning a text-video embedding by watching hundred million narrated video", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 116, + 374, + 270, + 386 + ], + "spans": [ + { + "bbox": [ + 116, + 374, + 270, + 386 + ], + "score": 1.0, + "content": "clips. In ICCV, pp. 2630–2640, 2019.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 106, + 392, + 503, + 415 + ], + "lines": [ + { + "bbox": [ + 106, + 392, + 504, + 405 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 504, + 405 + ], + "score": 1.0, + "content": "Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representa-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 404, + 272, + 414 + ], + "spans": [ + { + "bbox": [ + 116, + 404, + 272, + 414 + ], + "score": 1.0, + "content": "tions. In CVPR, pp. 6707–6717, 2020.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 106, + 421, + 502, + 445 + ], + "lines": [ + { + "bbox": [ + 104, + 418, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 104, + 418, + 505, + 437 + ], + "score": 1.0, + "content": "Ishan Misra, C. Lawrence Zitnick, and Martial Hebert. Shuffle and learn: Unsupervised learning", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 433, + 374, + 445 + ], + "spans": [ + { + "bbox": [ + 115, + 433, + 374, + 445 + ], + "score": 1.0, + "content": "using temporal order verification. In ECCV, pp. 527–544, 2016.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 106, + 451, + 503, + 474 + ], + "lines": [ + { + "bbox": [ + 105, + 450, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 505, + 465 + ], + "score": 1.0, + "content": "Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 462, + 263, + 475 + ], + "spans": [ + { + "bbox": [ + 115, + 462, + 263, + 475 + ], + "score": 1.0, + "content": "puzzles. In ECCV, pp. 69–84, 2016.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 106, + 480, + 503, + 504 + ], + "lines": [ + { + "bbox": [ + 106, + 481, + 505, + 494 + ], + "spans": [ + { + "bbox": [ + 106, + 481, + 505, + 494 + ], + "score": 1.0, + "content": "Marie-Morgane Paumard, David Picard, and Hedi Tabia. Deepzzle: Solving visual jigsaw puzzles", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 492, + 427, + 504 + ], + "spans": [ + { + "bbox": [ + 115, + 492, + 427, + 504 + ], + "score": 1.0, + "content": "with deep learning and shortest path optimization. TIP, 29:3569–3581, 2020.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 106, + 510, + 504, + 544 + ], + "lines": [ + { + "bbox": [ + 105, + 508, + 506, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 508, + 506, + 524 + ], + "score": 1.0, + "content": "Rui Qian, Tianjian Meng, Boqing Gong, Ming-Hsuan Yang, Huisheng Wang, Serge Belongie,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 520, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 115, + 520, + 505, + 534 + ], + "score": 1.0, + "content": "and Yin Cui. Spatiotemporal contrastive video representation learning. arXiv preprint", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 532, + 219, + 544 + ], + "spans": [ + { + "bbox": [ + 115, + 532, + 219, + 544 + ], + "score": 1.0, + "content": "arXiv:2008.03800, 2020.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 106, + 550, + 505, + 574 + ], + "lines": [ + { + "bbox": [ + 106, + 550, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 505, + 563 + ], + "score": 1.0, + "content": "Khurram Soomro, Amir Roshan Zamir, and Mubarak Shah. Ucf101: A dataset of 101 human actions", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 115, + 561, + 403, + 574 + ], + "spans": [ + { + "bbox": [ + 115, + 561, + 403, + 574 + ], + "score": 1.0, + "content": "classes from videos in the wild. arXiv preprint arXiv:1212.0402, 2012.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33.5 + }, + { + "type": "text", + "bbox": [ + 107, + 579, + 504, + 614 + ], + "lines": [ + { + "bbox": [ + 106, + 579, + 505, + 593 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 505, + 593 + ], + "score": 1.0, + "content": "Simon M. Stringer, Gavin Perry, Edmund T. Rolls, and J. H. Proske. Learning invariant object", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 114, + 591, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 114, + 591, + 505, + 605 + ], + "score": 1.0, + "content": "recognition in the visual system with continuous transformations. Biological Cybernetics, 94(2):", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 117, + 602, + 181, + 614 + ], + "spans": [ + { + "bbox": [ + 117, + 602, + 181, + 614 + ], + "score": 1.0, + "content": "128–142, 2006.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36 + }, + { + "type": "text", + "bbox": [ + 106, + 621, + 503, + 644 + ], + "lines": [ + { + "bbox": [ + 106, + 621, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 621, + 505, + 633 + ], + "score": 1.0, + "content": "Chen Sun, Fabien Baradel, Kevin Murphy, and Cordelia Schmid. Learning video representations", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 632, + 453, + 644 + ], + "spans": [ + { + "bbox": [ + 116, + 632, + 453, + 644 + ], + "score": 1.0, + "content": "using contrastive bidirectional transformer. arXiv preprint arXiv:1906.05743, 2019.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5 + }, + { + "type": "text", + "bbox": [ + 106, + 650, + 496, + 663 + ], + "lines": [ + { + "bbox": [ + 106, + 649, + 495, + 663 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 495, + 663 + ], + "score": 1.0, + "content": "Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. In ECCV, 2020.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 106, + 668, + 503, + 703 + ], + "lines": [ + { + "bbox": [ + 106, + 668, + 505, + 682 + ], + "spans": [ + { + "bbox": [ + 106, + 668, + 505, + 682 + ], + "score": 1.0, + "content": "Jiangliu Wang, Jianbo Jiao, Linchao Bao, Shengfeng He, Yunhui Liu, and Wei Liu. Self-supervised", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 680, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 115, + 680, + 505, + 693 + ], + "score": 1.0, + "content": "spatio-temporal representation learning for videos by predicting motion and appearance statistics.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 691, + 247, + 703 + ], + "spans": [ + { + "bbox": [ + 115, + 691, + 247, + 703 + ], + "score": 1.0, + "content": "In CVPR, pp. 4006–4015, 2019.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "Jiangliu Wang, Jianbo Jiao, and Yun-Hui Liu. Self-supervised video representation learning by pace", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 721, + 229, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 229, + 732 + ], + "score": 1.0, + "content": "prediction. In ECCV, 2020.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 502, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 95 + ], + "score": 1.0, + "content": "Joshua Knights, Anthony Vanderkop, Daniel Ward, Olivia Mackenzie-Ross, and Peyman", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 92, + 504, + 107 + ], + "spans": [ + { + "bbox": [ + 115, + 92, + 504, + 107 + ], + "score": 1.0, + "content": "Moghadam. Temporally coherent embeddings for self-supervised video representation learning.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 116, + 104, + 279, + 116 + ], + "spans": [ + { + "bbox": [ + 116, + 104, + 279, + 116 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:2004.02753, 2020.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 105, + 81, + 505, + 116 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 122, + 504, + 146 + ], + "lines": [ + { + "bbox": [ + 106, + 123, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 106, + 123, + 505, + 136 + ], + "score": 1.0, + "content": "Bruno Korbar, Du Tran, and Lorenzo Torresani. Cooperative learning of audio and video models", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 116, + 133, + 410, + 146 + ], + "spans": [ + { + "bbox": [ + 116, + 133, + 410, + 146 + ], + "score": 1.0, + "content": "from self-supervised synchronization. In NeurIPS, pp. 7763–7774, 2018.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5, + "bbox_fs": [ + 106, + 123, + 505, + 146 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 152, + 504, + 186 + ], + "lines": [ + { + "bbox": [ + 105, + 151, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 505, + 165 + ], + "score": 1.0, + "content": "Hilde Kuehne, Ali Arslan, and Thomas Serre. The language of actions: Recovering the syntax and", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 116, + 163, + 506, + 177 + ], + "spans": [ + { + "bbox": [ + 116, + 163, + 506, + 177 + ], + "score": 1.0, + "content": "semantics of goal-directed human activities. In Proceedings of the IEEE conference on computer", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 174, + 322, + 187 + ], + "spans": [ + { + "bbox": [ + 116, + 174, + 322, + 187 + ], + "score": 1.0, + "content": "vision and pattern recognition, pp. 780–787, 2014.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6, + "bbox_fs": [ + 105, + 151, + 506, + 187 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 192, + 504, + 227 + ], + "lines": [ + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "score": 1.0, + "content": "Hildegard Kuehne, Hueihan Jhuang, Estibaliz Garrote, Tomaso Poggio, and Thomas Serre. Hmdb:", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 116, + 205, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 116, + 205, + 505, + 216 + ], + "score": 1.0, + "content": "A large video database for human motion recognition. In Proceedings of the IEEE International", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 117, + 215, + 339, + 227 + ], + "spans": [ + { + "bbox": [ + 117, + 215, + 339, + 227 + ], + "score": 1.0, + "content": "Conference on Computer Vision, pp. 2556–2563, 2011.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9, + "bbox_fs": [ + 105, + 192, + 505, + 227 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 233, + 502, + 257 + ], + "lines": [ + { + "bbox": [ + 105, + 232, + 504, + 247 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 504, + 247 + ], + "score": 1.0, + "content": "Hsin-Ying Lee, Jia-Bin Huang, Maneesh Singh, and Ming-Hsuan Yang. Unsupervised representa-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 115, + 245, + 378, + 256 + ], + "spans": [ + { + "bbox": [ + 115, + 245, + 378, + 256 + ], + "score": 1.0, + "content": "tion learning by sorting sequences. In ICCV, pp. 667–676, 2017.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 232, + 504, + 256 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 262, + 502, + 286 + ], + "lines": [ + { + "bbox": [ + 106, + 263, + 503, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 263, + 503, + 276 + ], + "score": 1.0, + "content": "Tsung-Yi Lin, Piotr Dollar, Ross Girshick, Kaiming He, Bharath Hariharan, and Serge Belongie.´", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 115, + 274, + 437, + 286 + ], + "spans": [ + { + "bbox": [ + 115, + 274, + 437, + 286 + ], + "score": 1.0, + "content": "Feature pyramid networks for object detection. In CVPR, pp. 2117–2125, 2017.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5, + "bbox_fs": [ + 106, + 263, + 503, + 286 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 292, + 504, + 316 + ], + "lines": [ + { + "bbox": [ + 106, + 292, + 505, + 305 + ], + "spans": [ + { + "bbox": [ + 106, + 292, + 505, + 305 + ], + "score": 1.0, + "content": "Dezhao Luo, Bo Fang, Yu Zhou, Yucan Zhou, Dayan Wu, and Weiping Wang. Exploring relations", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 303, + 483, + 316 + ], + "spans": [ + { + "bbox": [ + 115, + 303, + 483, + 316 + ], + "score": 1.0, + "content": "in untrimmed videos for self-supervised learning. arXiv preprint arXiv:2008.02711, 2020a.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5, + "bbox_fs": [ + 106, + 292, + 505, + 316 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 321, + 504, + 345 + ], + "lines": [ + { + "bbox": [ + 106, + 322, + 505, + 335 + ], + "spans": [ + { + "bbox": [ + 106, + 322, + 505, + 335 + ], + "score": 1.0, + "content": "Dezhao Luo, Chang Liu, Yu Zhou, Dongbao Yang, Can Ma, Qixiang Ye, and Weiping Wang. Video", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 116, + 333, + 430, + 345 + ], + "spans": [ + { + "bbox": [ + 116, + 333, + 430, + 345 + ], + "score": 1.0, + "content": "cloze procedure for self-supervised spatio-temporal learning. In AAAI, 2020b.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5, + "bbox_fs": [ + 106, + 322, + 505, + 345 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 351, + 504, + 385 + ], + "lines": [ + { + "bbox": [ + 106, + 351, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 505, + 364 + ], + "score": 1.0, + "content": "Antoine Miech, Dimitri Zhukov, Jean-Baptiste Alayrac, Makarand Tapaswi, Ivan Laptev, and Josef", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 362, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 115, + 362, + 505, + 375 + ], + "score": 1.0, + "content": "Sivic. Howto100m: Learning a text-video embedding by watching hundred million narrated video", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 116, + 374, + 270, + 386 + ], + "spans": [ + { + "bbox": [ + 116, + 374, + 270, + 386 + ], + "score": 1.0, + "content": "clips. In ICCV, pp. 2630–2640, 2019.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20, + "bbox_fs": [ + 106, + 351, + 505, + 386 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 392, + 503, + 415 + ], + "lines": [ + { + "bbox": [ + 106, + 392, + 504, + 405 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 504, + 405 + ], + "score": 1.0, + "content": "Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representa-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 404, + 272, + 414 + ], + "spans": [ + { + "bbox": [ + 116, + 404, + 272, + 414 + ], + "score": 1.0, + "content": "tions. In CVPR, pp. 6707–6717, 2020.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 106, + 392, + 504, + 414 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 421, + 502, + 445 + ], + "lines": [ + { + "bbox": [ + 104, + 418, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 104, + 418, + 505, + 437 + ], + "score": 1.0, + "content": "Ishan Misra, C. Lawrence Zitnick, and Martial Hebert. Shuffle and learn: Unsupervised learning", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 433, + 374, + 445 + ], + "spans": [ + { + "bbox": [ + 115, + 433, + 374, + 445 + ], + "score": 1.0, + "content": "using temporal order verification. In ECCV, pp. 527–544, 2016.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5, + "bbox_fs": [ + 104, + 418, + 505, + 445 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 451, + 503, + 474 + ], + "lines": [ + { + "bbox": [ + 105, + 450, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 505, + 465 + ], + "score": 1.0, + "content": "Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 462, + 263, + 475 + ], + "spans": [ + { + "bbox": [ + 115, + 462, + 263, + 475 + ], + "score": 1.0, + "content": "puzzles. In ECCV, pp. 69–84, 2016.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 450, + 505, + 475 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 480, + 503, + 504 + ], + "lines": [ + { + "bbox": [ + 106, + 481, + 505, + 494 + ], + "spans": [ + { + "bbox": [ + 106, + 481, + 505, + 494 + ], + "score": 1.0, + "content": "Marie-Morgane Paumard, David Picard, and Hedi Tabia. Deepzzle: Solving visual jigsaw puzzles", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 492, + 427, + 504 + ], + "spans": [ + { + "bbox": [ + 115, + 492, + 427, + 504 + ], + "score": 1.0, + "content": "with deep learning and shortest path optimization. TIP, 29:3569–3581, 2020.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28.5, + "bbox_fs": [ + 106, + 481, + 505, + 504 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 510, + 504, + 544 + ], + "lines": [ + { + "bbox": [ + 105, + 508, + 506, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 508, + 506, + 524 + ], + "score": 1.0, + "content": "Rui Qian, Tianjian Meng, Boqing Gong, Ming-Hsuan Yang, Huisheng Wang, Serge Belongie,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 520, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 115, + 520, + 505, + 534 + ], + "score": 1.0, + "content": "and Yin Cui. Spatiotemporal contrastive video representation learning. arXiv preprint", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 532, + 219, + 544 + ], + "spans": [ + { + "bbox": [ + 115, + 532, + 219, + 544 + ], + "score": 1.0, + "content": "arXiv:2008.03800, 2020.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31, + "bbox_fs": [ + 105, + 508, + 506, + 544 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 550, + 505, + 574 + ], + "lines": [ + { + "bbox": [ + 106, + 550, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 505, + 563 + ], + "score": 1.0, + "content": "Khurram Soomro, Amir Roshan Zamir, and Mubarak Shah. Ucf101: A dataset of 101 human actions", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 115, + 561, + 403, + 574 + ], + "spans": [ + { + "bbox": [ + 115, + 561, + 403, + 574 + ], + "score": 1.0, + "content": "classes from videos in the wild. arXiv preprint arXiv:1212.0402, 2012.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33.5, + "bbox_fs": [ + 106, + 550, + 505, + 574 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 579, + 504, + 614 + ], + "lines": [ + { + "bbox": [ + 106, + 579, + 505, + 593 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 505, + 593 + ], + "score": 1.0, + "content": "Simon M. Stringer, Gavin Perry, Edmund T. Rolls, and J. H. Proske. Learning invariant object", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 114, + 591, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 114, + 591, + 505, + 605 + ], + "score": 1.0, + "content": "recognition in the visual system with continuous transformations. Biological Cybernetics, 94(2):", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 117, + 602, + 181, + 614 + ], + "spans": [ + { + "bbox": [ + 117, + 602, + 181, + 614 + ], + "score": 1.0, + "content": "128–142, 2006.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36, + "bbox_fs": [ + 106, + 579, + 505, + 614 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 621, + 503, + 644 + ], + "lines": [ + { + "bbox": [ + 106, + 621, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 621, + 505, + 633 + ], + "score": 1.0, + "content": "Chen Sun, Fabien Baradel, Kevin Murphy, and Cordelia Schmid. Learning video representations", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 632, + 453, + 644 + ], + "spans": [ + { + "bbox": [ + 116, + 632, + 453, + 644 + ], + "score": 1.0, + "content": "using contrastive bidirectional transformer. arXiv preprint arXiv:1906.05743, 2019.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5, + "bbox_fs": [ + 106, + 621, + 505, + 644 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 650, + 496, + 663 + ], + "lines": [ + { + "bbox": [ + 106, + 649, + 495, + 663 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 495, + 663 + ], + "score": 1.0, + "content": "Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. In ECCV, 2020.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40, + "bbox_fs": [ + 106, + 649, + 495, + 663 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 668, + 503, + 703 + ], + "lines": [ + { + "bbox": [ + 106, + 668, + 505, + 682 + ], + "spans": [ + { + "bbox": [ + 106, + 668, + 505, + 682 + ], + "score": 1.0, + "content": "Jiangliu Wang, Jianbo Jiao, Linchao Bao, Shengfeng He, Yunhui Liu, and Wei Liu. Self-supervised", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 680, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 115, + 680, + 505, + 693 + ], + "score": 1.0, + "content": "spatio-temporal representation learning for videos by predicting motion and appearance statistics.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 691, + 247, + 703 + ], + "spans": [ + { + "bbox": [ + 115, + 691, + 247, + 703 + ], + "score": 1.0, + "content": "In CVPR, pp. 4006–4015, 2019.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42, + "bbox_fs": [ + 106, + 668, + 505, + 703 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "Jiangliu Wang, Jianbo Jiao, and Yun-Hui Liu. Self-supervised video representation learning by pace", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 721, + 229, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 229, + 732 + ], + "score": 1.0, + "content": "prediction. In ECCV, 2020.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5, + "bbox_fs": [ + 105, + 708, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 80, + 506, + 286 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 506, + 97 + ], + "score": 1.0, + "content": "Xiaolong Wang, Ross Girshick, Abhinav Gupta, and Kaiming He. Non-local neural networks. In", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 116, + 94, + 236, + 107 + ], + "spans": [ + { + "bbox": [ + 116, + 94, + 236, + 107 + ], + "score": 1.0, + "content": "CVPR, pp. 7794–7803, 2018.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 111, + 505, + 126 + ], + "spans": [ + { + "bbox": [ + 105, + 111, + 505, + 126 + ], + "score": 1.0, + "content": "Donglai Wei, Joseph Lim, Andrew Zisserman, and William T. Freeman. Learning and using the", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 116, + 123, + 307, + 137 + ], + "spans": [ + { + "bbox": [ + 116, + 123, + 307, + 137 + ], + "score": 1.0, + "content": "arrow of time. In CVPR, pp. 8052–8060, 2018.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 142, + 504, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 504, + 156 + ], + "score": 1.0, + "content": "Zhirong Wu, Yuanjun Xiong, Stella X Yu, and Dahua Lin. Unsupervised feature learning via non-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 154, + 391, + 167 + ], + "spans": [ + { + "bbox": [ + 115, + 154, + 391, + 167 + ], + "score": 1.0, + "content": "parametric instance discrimination. In CVPR, pp. 3733–3742, 2018.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 171, + 505, + 187 + ], + "spans": [ + { + "bbox": [ + 104, + 171, + 505, + 187 + ], + "score": 1.0, + "content": "Dejing Xu, Jun Xiao, Zhou Zhao, Jian Shao, Di Xie, and Yueting Zhuang. Self-supervised spa-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 183, + 468, + 197 + ], + "spans": [ + { + "bbox": [ + 115, + 183, + 468, + 197 + ], + "score": 1.0, + "content": "tiotemporal learning via video clip order prediction. In CVPR, pp. 10334–10343, 2019.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 202, + 506, + 216 + ], + "spans": [ + { + "bbox": [ + 106, + 202, + 506, + 216 + ], + "score": 1.0, + "content": "Ceyuan Yang, Yinghao Xu, Bo Dai, and Bolei Zhou. Video representation learning with visual", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 214, + 358, + 226 + ], + "spans": [ + { + "bbox": [ + 115, + 214, + 358, + 226 + ], + "score": 1.0, + "content": "tempo consistency. arXiv preprint arXiv:2006.15489, 2020.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 231, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 106, + 231, + 505, + 246 + ], + "score": 1.0, + "content": "Yuan Yao, Chang Liu, Dezhao Luo, Yu Zhou, and Qixiang Ye. Video playback rate perception for", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 243, + 472, + 257 + ], + "spans": [ + { + "bbox": [ + 115, + 243, + 472, + 257 + ], + "score": 1.0, + "content": "self-supervised spatio-temporal representation learning. In CVPR, pp. 6548–6557, 2020.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 262, + 505, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 262, + 505, + 276 + ], + "score": 1.0, + "content": "Chengxu Zhuang, Tianwei She, Alex Andonian, Max Sobol Mark, and Daniel Yamins. Unsuper-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 273, + 474, + 286 + ], + "spans": [ + { + "bbox": [ + 116, + 273, + 474, + 286 + ], + "score": 1.0, + "content": "vised learning from video with deep neural embeddings. In CVPR, pp. 9563–9572, 2020.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 6.5 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "12", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 38 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 105, + 80, + 506, + 286 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 506, + 97 + ], + "score": 1.0, + "content": "Xiaolong Wang, Ross Girshick, Abhinav Gupta, and Kaiming He. Non-local neural networks. In", + "type": "text" + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 94, + 236, + 107 + ], + "spans": [ + { + "bbox": [ + 116, + 94, + 236, + 107 + ], + "score": 1.0, + "content": "CVPR, pp. 7794–7803, 2018.", + "type": "text" + } + ], + "index": 1, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 111, + 505, + 126 + ], + "spans": [ + { + "bbox": [ + 105, + 111, + 505, + 126 + ], + "score": 1.0, + "content": "Donglai Wei, Joseph Lim, Andrew Zisserman, and William T. Freeman. Learning and using the", + "type": "text" + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 123, + 307, + 137 + ], + "spans": [ + { + "bbox": [ + 116, + 123, + 307, + 137 + ], + "score": 1.0, + "content": "arrow of time. In CVPR, pp. 8052–8060, 2018.", + "type": "text" + } + ], + "index": 3, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 142, + 504, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 504, + 156 + ], + "score": 1.0, + "content": "Zhirong Wu, Yuanjun Xiong, Stella X Yu, and Dahua Lin. Unsupervised feature learning via non-", + "type": "text" + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 154, + 391, + 167 + ], + "spans": [ + { + "bbox": [ + 115, + 154, + 391, + 167 + ], + "score": 1.0, + "content": "parametric instance discrimination. In CVPR, pp. 3733–3742, 2018.", + "type": "text" + } + ], + "index": 5, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 171, + 505, + 187 + ], + "spans": [ + { + "bbox": [ + 104, + 171, + 505, + 187 + ], + "score": 1.0, + "content": "Dejing Xu, Jun Xiao, Zhou Zhao, Jian Shao, Di Xie, and Yueting Zhuang. Self-supervised spa-", + "type": "text" + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 183, + 468, + 197 + ], + "spans": [ + { + "bbox": [ + 115, + 183, + 468, + 197 + ], + "score": 1.0, + "content": "tiotemporal learning via video clip order prediction. In CVPR, pp. 10334–10343, 2019.", + "type": "text" + } + ], + "index": 7, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 202, + 506, + 216 + ], + "spans": [ + { + "bbox": [ + 106, + 202, + 506, + 216 + ], + "score": 1.0, + "content": "Ceyuan Yang, Yinghao Xu, Bo Dai, and Bolei Zhou. Video representation learning with visual", + "type": "text" + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 214, + 358, + 226 + ], + "spans": [ + { + "bbox": [ + 115, + 214, + 358, + 226 + ], + "score": 1.0, + "content": "tempo consistency. arXiv preprint arXiv:2006.15489, 2020.", + "type": "text" + } + ], + "index": 9, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 231, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 106, + 231, + 505, + 246 + ], + "score": 1.0, + "content": "Yuan Yao, Chang Liu, Dezhao Luo, Yu Zhou, and Qixiang Ye. Video playback rate perception for", + "type": "text" + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 243, + 472, + 257 + ], + "spans": [ + { + "bbox": [ + 115, + 243, + 472, + 257 + ], + "score": 1.0, + "content": "self-supervised spatio-temporal representation learning. In CVPR, pp. 6548–6557, 2020.", + "type": "text" + } + ], + "index": 11, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 262, + 505, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 262, + 505, + 276 + ], + "score": 1.0, + "content": "Chengxu Zhuang, Tianwei She, Alex Andonian, Max Sobol Mark, and Daniel Yamins. Unsuper-", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 273, + 474, + 286 + ], + "spans": [ + { + "bbox": [ + 116, + 273, + 474, + 286 + ], + "score": 1.0, + "content": "vised learning from video with deep neural embeddings. In CVPR, pp. 9563–9572, 2020.", + "type": "text" + } + ], + "index": 13, + "is_list_end_line": true + } + ], + "index": 6.5, + "bbox_fs": [ + 104, + 82, + 506, + 286 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 320, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 322, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 322, + 96 + ], + "score": 1.0, + "content": "A ADDITIONAL LEARNING STRATEGIES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 108, + 102, + 218, + 113 + ], + "lines": [ + { + "bbox": [ + 106, + 102, + 219, + 115 + ], + "spans": [ + { + "bbox": [ + 106, + 102, + 219, + 115 + ], + "score": 1.0, + "content": "A.1 ADAPTIVE WEIGHT", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 122, + 505, + 156 + ], + "lines": [ + { + "bbox": [ + 105, + 123, + 505, + 135 + ], + "spans": [ + { + "bbox": [ + 105, + 123, + 300, + 135 + ], + "score": 1.0, + "content": "Formally, our CSJ has two continuous outputs", + "type": "text" + }, + { + "bbox": [ + 301, + 125, + 326, + 134 + ], + "score": 0.89, + "content": "\\mathrm { y } _ { 1 } , \\mathrm { y } _ { 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 327, + 123, + 505, + 135 + ], + "score": 1.0, + "content": "from LCCD and CCMR, and two discrete", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 133, + 506, + 147 + ], + "spans": [ + { + "bbox": [ + 105, + 133, + 138, + 147 + ], + "score": 1.0, + "content": "outputs", + "type": "text" + }, + { + "bbox": [ + 138, + 136, + 164, + 146 + ], + "score": 0.89, + "content": "\\mathrm { y } _ { 2 } , \\mathrm { y } _ { 3 }", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 133, + 506, + 147 + ], + "score": 1.0, + "content": "from CSPC and CLSC, modeled with Gaussian likelihoods and softmax likelihoods,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 145, + 394, + 158 + ], + "spans": [ + { + "bbox": [ + 105, + 145, + 294, + 158 + ], + "score": 1.0, + "content": "respectively. The joint loss for these four tasks", + "type": "text" + }, + { + "bbox": [ + 295, + 145, + 380, + 157 + ], + "score": 0.91, + "content": "L ( \\mathbf { W } , \\sigma _ { 1 } , \\sigma _ { 2 } , \\sigma _ { 3 } , \\sigma _ { 4 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 145, + 394, + 158 + ], + "score": 1.0, + "content": "is:", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3 + }, + { + "type": "interline_equation", + "bbox": [ + 180, + 162, + 432, + 284 + ], + "lines": [ + { + "bbox": [ + 180, + 162, + 432, + 284 + ], + "spans": [ + { + "bbox": [ + 180, + 162, + 432, + 284 + ], + "score": 0.95, + "content": "\\begin{array} { r l } & { L ( \\mathbf { W } , \\sigma _ { 1 } , \\sigma _ { 2 } , \\sigma _ { 3 } , \\sigma _ { 4 } ) } \\\\ & { = - \\log \\mathcal { N } ( \\mathbf { y } _ { 1 } ; \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) , \\sigma _ { 1 } ^ { 2 } ) \\cdot - \\log \\mathcal { N } ( \\mathbf { y } _ { 4 } ; \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) , \\sigma _ { 4 } ^ { 2 } ) } \\\\ & { \\quad \\cdot \\ \\mathrm { s o f t m a x } ( \\mathbf { y } _ { 2 } = \\sigma ; \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) , \\sigma _ { 2 } ) \\cdot \\mathrm { s o f t m a x } ( \\mathbf { y } _ { 3 } = \\sigma ; \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) , \\sigma _ { 3 } ) } \\\\ & { = \\frac { 1 } { 2 \\sigma _ { 1 } ^ { 2 } } | | \\mathbf { y } _ { 1 } - \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) | | ^ { 2 } + \\log \\sigma _ { 1 } - \\frac { 1 } { 2 \\sigma _ { 4 } ^ { 2 } } | | \\mathbf { y } _ { 4 } - \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) | | ^ { 2 } + \\log \\sigma _ { 4 } } \\\\ & { \\quad - \\log p ( \\mathbf { y } _ { 2 } | \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) , \\sigma _ { 2 } ) - \\log p ( \\mathbf { y } _ { 3 } | \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) , \\sigma _ { 3 } ) } \\\\ & { \\approx \\frac { 1 } { 2 \\sigma _ { 1 } ^ { 2 } } L ( \\mathbf { W } ) + \\frac { 1 } { \\sigma _ { 2 } ^ { 2 } } L _ { 2 } ( \\mathbf { W } ) + \\frac { 1 } { \\sigma _ { 3 } ^ { 2 } } L _ { 3 } ( \\mathbf { W } ) + \\frac { 1 } { 2 \\sigma _ { 4 } ^ { 2 } } L _ { 4 } ( \\mathbf { W } ) } \\\\ & { \\quad + \\log \\sigma _ { 1 } + \\log \\sigma _ { 2 } + \\log \\sigma _ { 3 } + \\log \\sigma _ { 4 } , } \\end{array}", + "type": "interline_equation", + "image_path": "eace98d6fd67a272c42110dcb931d7c8a8bb1b5dec0450ddff107a6c4d778bac.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 180, + 162, + 432, + 202.66666666666666 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 180, + 202.66666666666666, + 432, + 243.33333333333331 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 180, + 243.33333333333331, + 432, + 284.0 + ], + "spans": [], + "index": 7 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 289, + 503, + 311 + ], + "lines": [ + { + "bbox": [ + 105, + 288, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 133, + 301 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 291, + 141, + 299 + ], + "score": 0.78, + "content": "\\sigma", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 288, + 505, + 301 + ], + "score": 1.0, + "content": "is the weight factor that can be automatically learned from the network, and the log likeli-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 299, + 248, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 299, + 248, + 312 + ], + "score": 1.0, + "content": "hood for the output y is defined as:", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5 + }, + { + "type": "interline_equation", + "bbox": [ + 177, + 316, + 435, + 346 + ], + "lines": [ + { + "bbox": [ + 177, + 316, + 435, + 346 + ], + "spans": [ + { + "bbox": [ + 177, + 316, + 435, + 346 + ], + "score": 0.93, + "content": "\\log p ( \\mathrm { y } = c | \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) , \\boldsymbol { \\sigma } ) = \\frac { 1 } { \\sigma ^ { 2 } } f _ { c } ^ { \\mathbf { W } } ( \\mathbf { x } ) - \\log \\sum _ { c ^ { \\prime } } \\exp ( \\frac { 1 } { \\sigma ^ { 2 } } f _ { c ^ { \\prime } } ^ { \\mathbf { W } } ( \\mathbf { x } ) ) .", + "type": "interline_equation", + "image_path": "219cae6835b9b3bca98ca92291b26056a8ac279f29e4a8cfc8e10411da527631.jpg" + } + ] + } + ], + "index": 11, + "virtual_lines": [ + { + "bbox": [ + 177, + 316, + 435, + 326.0 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 177, + 326.0, + 435, + 336.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 177, + 336.0, + 435, + 346.0 + ], + "spans": [], + "index": 12 + } + ] + }, + { + "type": "title", + "bbox": [ + 108, + 361, + 242, + 372 + ], + "lines": [ + { + "bbox": [ + 106, + 361, + 243, + 374 + ], + "spans": [ + { + "bbox": [ + 106, + 361, + 243, + 374 + ], + "score": 1.0, + "content": "A.2 CURRICULUM LEARNING", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 106, + 381, + 505, + 481 + ], + "lines": [ + { + "bbox": [ + 105, + 381, + 505, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 505, + 395 + ], + "score": 1.0, + "content": "We adopt curriculum learning (Korbar et al., 2018) to train our network by shuffling clips from", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 392, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 392, + 176, + 407 + ], + "score": 1.0, + "content": "easy to hard. Let", + "type": "text" + }, + { + "bbox": [ + 176, + 394, + 183, + 403 + ], + "score": 0.77, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 392, + 337, + 407 + ], + "score": 1.0, + "content": "be the shuffle degree of a shuffled clip", + "type": "text" + }, + { + "bbox": [ + 337, + 393, + 345, + 403 + ], + "score": 0.83, + "content": "\\widetilde { \\pmb x }", + "type": "inline_equation" + }, + { + "bbox": [ + 345, + 392, + 505, + 407 + ], + "score": 1.0, + "content": ", representing the number of continuous", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 307, + 416 + ], + "score": 1.0, + "content": "cuboids in each dimension. We gradually increase", + "type": "text" + }, + { + "bbox": [ + 307, + 405, + 313, + 414 + ], + "score": 0.78, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 404, + 505, + 416 + ], + "score": 1.0, + "content": "efrom 3 to 5 during the training phase to produce", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 415, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 505, + 428 + ], + "score": 1.0, + "content": "more permuted clips. Note that when the video content is ambiguous in one dimension, e.g., a static", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 426, + 506, + 439 + ], + "spans": [ + { + "bbox": [ + 106, + 426, + 506, + 439 + ], + "score": 1.0, + "content": "video clip inflated from an image, there is no temporal variance to learn the transformation. Kim", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 436, + 505, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 436, + 505, + 451 + ], + "score": 1.0, + "content": "et al. (2019); Noroozi & Favaro (2016) also mentioned this problem as similar-looking ambiguity.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 448, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 505, + 460 + ], + "score": 1.0, + "content": "To solve this problem, we calculate the variance on each dimension and set a threshold. If the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 459, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 106, + 459, + 304, + 471 + ], + "score": 1.0, + "content": "variance is lower than the threshold, we decrease", + "type": "text" + }, + { + "bbox": [ + 304, + 459, + 311, + 469 + ], + "score": 0.77, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 459, + 505, + 471 + ], + "score": 1.0, + "content": "from 3 to 1 so that the pieces are not shuffled in", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 470, + 226, + 482 + ], + "spans": [ + { + "bbox": [ + 106, + 470, + 226, + 482 + ], + "score": 1.0, + "content": "the corresponding dimension.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 18 + }, + { + "type": "title", + "bbox": [ + 107, + 493, + 302, + 506 + ], + "lines": [ + { + "bbox": [ + 105, + 493, + 304, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 304, + 508 + ], + "score": 1.0, + "content": "B DATASETS AND IMPLEMENTATION", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "title", + "bbox": [ + 108, + 514, + 231, + 526 + ], + "lines": [ + { + "bbox": [ + 106, + 514, + 232, + 526 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 232, + 526 + ], + "score": 1.0, + "content": "B.1 DETAILS OF DATASETS", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 535, + 505, + 579 + ], + "lines": [ + { + "bbox": [ + 105, + 535, + 505, + 548 + ], + "spans": [ + { + "bbox": [ + 105, + 535, + 505, + 548 + ], + "score": 1.0, + "content": "UCF101 (Soomro et al., 2012) is a widely-used dataset in the action recognition task, which contains", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 546, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 546, + 505, + 559 + ], + "score": 1.0, + "content": "13,320 videos with 101 action classes. The dataset is divided into three training/testing splits. In", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 556, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 506, + 570 + ], + "score": 1.0, + "content": "this paper, following prior works (Wang et al., 2020; Han et al., 2020), we use the first training split", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 568, + 370, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 568, + 370, + 581 + ], + "score": 1.0, + "content": "as the pre-training dataset and the first testing split for evaluation.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 107, + 585, + 505, + 629 + ], + "lines": [ + { + "bbox": [ + 105, + 585, + 505, + 597 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 505, + 597 + ], + "score": 1.0, + "content": "HMDB51 (Kuehne et al., 2011) is a relatively small action recognition dataset, consisting of 6,766", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 595, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 505, + 609 + ], + "score": 1.0, + "content": "videos with 51 categories. It is also divided into three training/testing splits. Following Wang et al.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 606, + 505, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 505, + 620 + ], + "score": 1.0, + "content": "(2020); Han et al. (2020), we use the first training split as the pre-training dataset and the first testing", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 618, + 186, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 186, + 630 + ], + "score": 1.0, + "content": "split for evaluation.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30.5 + }, + { + "type": "text", + "bbox": [ + 107, + 634, + 505, + 668 + ], + "lines": [ + { + "bbox": [ + 105, + 633, + 505, + 648 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 505, + 648 + ], + "score": 1.0, + "content": "Kinetics-400 (K400) (Kay et al., 2017) is a very large action recognition dataset consisting of 400", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 646, + 504, + 658 + ], + "spans": [ + { + "bbox": [ + 106, + 646, + 504, + 658 + ], + "score": 1.0, + "content": "human action classes and around 306k videos. In this work, we use the training split of K400 as the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 658, + 189, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 189, + 669 + ], + "score": 1.0, + "content": "pre-training dataset.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34 + }, + { + "type": "title", + "bbox": [ + 108, + 677, + 250, + 689 + ], + "lines": [ + { + "bbox": [ + 105, + 677, + 252, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 252, + 690 + ], + "score": 1.0, + "content": "B.2 IMPLEMENTATION DETAILS", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 36 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "In the fine-tuning stage, weights of convolutional layers are initialized with self-supervised pre-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 710, + 506, + 721 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 506, + 721 + ], + "score": 1.0, + "content": "training, but weights of fully-connected layers are randomly initialized. The whole network is then", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "trained with the cross-entropy loss. The pre-processing and training strategies are the same as in the", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38 + } + ], + "page_idx": 12, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 301, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 298, + 750, + 312, + 763 + ], + "spans": [ + { + "bbox": [ + 298, + 750, + 312, + 763 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 13, + "width": 14 + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 106, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 320, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 322, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 322, + 96 + ], + "score": 1.0, + "content": "A ADDITIONAL LEARNING STRATEGIES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 108, + 102, + 218, + 113 + ], + "lines": [ + { + "bbox": [ + 106, + 102, + 219, + 115 + ], + "spans": [ + { + "bbox": [ + 106, + 102, + 219, + 115 + ], + "score": 1.0, + "content": "A.1 ADAPTIVE WEIGHT", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 122, + 505, + 156 + ], + "lines": [ + { + "bbox": [ + 105, + 123, + 505, + 135 + ], + "spans": [ + { + "bbox": [ + 105, + 123, + 300, + 135 + ], + "score": 1.0, + "content": "Formally, our CSJ has two continuous outputs", + "type": "text" + }, + { + "bbox": [ + 301, + 125, + 326, + 134 + ], + "score": 0.89, + "content": "\\mathrm { y } _ { 1 } , \\mathrm { y } _ { 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 327, + 123, + 505, + 135 + ], + "score": 1.0, + "content": "from LCCD and CCMR, and two discrete", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 133, + 506, + 147 + ], + "spans": [ + { + "bbox": [ + 105, + 133, + 138, + 147 + ], + "score": 1.0, + "content": "outputs", + "type": "text" + }, + { + "bbox": [ + 138, + 136, + 164, + 146 + ], + "score": 0.89, + "content": "\\mathrm { y } _ { 2 } , \\mathrm { y } _ { 3 }", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 133, + 506, + 147 + ], + "score": 1.0, + "content": "from CSPC and CLSC, modeled with Gaussian likelihoods and softmax likelihoods,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 145, + 394, + 158 + ], + "spans": [ + { + "bbox": [ + 105, + 145, + 294, + 158 + ], + "score": 1.0, + "content": "respectively. The joint loss for these four tasks", + "type": "text" + }, + { + "bbox": [ + 295, + 145, + 380, + 157 + ], + "score": 0.91, + "content": "L ( \\mathbf { W } , \\sigma _ { 1 } , \\sigma _ { 2 } , \\sigma _ { 3 } , \\sigma _ { 4 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 145, + 394, + 158 + ], + "score": 1.0, + "content": "is:", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3, + "bbox_fs": [ + 105, + 123, + 506, + 158 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 180, + 162, + 432, + 284 + ], + "lines": [ + { + "bbox": [ + 180, + 162, + 432, + 284 + ], + "spans": [ + { + "bbox": [ + 180, + 162, + 432, + 284 + ], + "score": 0.95, + "content": "\\begin{array} { r l } & { L ( \\mathbf { W } , \\sigma _ { 1 } , \\sigma _ { 2 } , \\sigma _ { 3 } , \\sigma _ { 4 } ) } \\\\ & { = - \\log \\mathcal { N } ( \\mathbf { y } _ { 1 } ; \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) , \\sigma _ { 1 } ^ { 2 } ) \\cdot - \\log \\mathcal { N } ( \\mathbf { y } _ { 4 } ; \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) , \\sigma _ { 4 } ^ { 2 } ) } \\\\ & { \\quad \\cdot \\ \\mathrm { s o f t m a x } ( \\mathbf { y } _ { 2 } = \\sigma ; \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) , \\sigma _ { 2 } ) \\cdot \\mathrm { s o f t m a x } ( \\mathbf { y } _ { 3 } = \\sigma ; \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) , \\sigma _ { 3 } ) } \\\\ & { = \\frac { 1 } { 2 \\sigma _ { 1 } ^ { 2 } } | | \\mathbf { y } _ { 1 } - \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) | | ^ { 2 } + \\log \\sigma _ { 1 } - \\frac { 1 } { 2 \\sigma _ { 4 } ^ { 2 } } | | \\mathbf { y } _ { 4 } - \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) | | ^ { 2 } + \\log \\sigma _ { 4 } } \\\\ & { \\quad - \\log p ( \\mathbf { y } _ { 2 } | \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) , \\sigma _ { 2 } ) - \\log p ( \\mathbf { y } _ { 3 } | \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) , \\sigma _ { 3 } ) } \\\\ & { \\approx \\frac { 1 } { 2 \\sigma _ { 1 } ^ { 2 } } L ( \\mathbf { W } ) + \\frac { 1 } { \\sigma _ { 2 } ^ { 2 } } L _ { 2 } ( \\mathbf { W } ) + \\frac { 1 } { \\sigma _ { 3 } ^ { 2 } } L _ { 3 } ( \\mathbf { W } ) + \\frac { 1 } { 2 \\sigma _ { 4 } ^ { 2 } } L _ { 4 } ( \\mathbf { W } ) } \\\\ & { \\quad + \\log \\sigma _ { 1 } + \\log \\sigma _ { 2 } + \\log \\sigma _ { 3 } + \\log \\sigma _ { 4 } , } \\end{array}", + "type": "interline_equation", + "image_path": "eace98d6fd67a272c42110dcb931d7c8a8bb1b5dec0450ddff107a6c4d778bac.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 180, + 162, + 432, + 202.66666666666666 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 180, + 202.66666666666666, + 432, + 243.33333333333331 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 180, + 243.33333333333331, + 432, + 284.0 + ], + "spans": [], + "index": 7 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 289, + 503, + 311 + ], + "lines": [ + { + "bbox": [ + 105, + 288, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 133, + 301 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 291, + 141, + 299 + ], + "score": 0.78, + "content": "\\sigma", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 288, + 505, + 301 + ], + "score": 1.0, + "content": "is the weight factor that can be automatically learned from the network, and the log likeli-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 299, + 248, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 299, + 248, + 312 + ], + "score": 1.0, + "content": "hood for the output y is defined as:", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 288, + 505, + 312 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 177, + 316, + 435, + 346 + ], + "lines": [ + { + "bbox": [ + 177, + 316, + 435, + 346 + ], + "spans": [ + { + "bbox": [ + 177, + 316, + 435, + 346 + ], + "score": 0.93, + "content": "\\log p ( \\mathrm { y } = c | \\mathbf { f } ^ { \\mathbf { W } } ( \\mathbf { x } ) , \\boldsymbol { \\sigma } ) = \\frac { 1 } { \\sigma ^ { 2 } } f _ { c } ^ { \\mathbf { W } } ( \\mathbf { x } ) - \\log \\sum _ { c ^ { \\prime } } \\exp ( \\frac { 1 } { \\sigma ^ { 2 } } f _ { c ^ { \\prime } } ^ { \\mathbf { W } } ( \\mathbf { x } ) ) .", + "type": "interline_equation", + "image_path": "219cae6835b9b3bca98ca92291b26056a8ac279f29e4a8cfc8e10411da527631.jpg" + } + ] + } + ], + "index": 11, + "virtual_lines": [ + { + "bbox": [ + 177, + 316, + 435, + 326.0 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 177, + 326.0, + 435, + 336.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 177, + 336.0, + 435, + 346.0 + ], + "spans": [], + "index": 12 + } + ] + }, + { + "type": "title", + "bbox": [ + 108, + 361, + 242, + 372 + ], + "lines": [ + { + "bbox": [ + 106, + 361, + 243, + 374 + ], + "spans": [ + { + "bbox": [ + 106, + 361, + 243, + 374 + ], + "score": 1.0, + "content": "A.2 CURRICULUM LEARNING", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 106, + 381, + 505, + 481 + ], + "lines": [ + { + "bbox": [ + 105, + 381, + 505, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 505, + 395 + ], + "score": 1.0, + "content": "We adopt curriculum learning (Korbar et al., 2018) to train our network by shuffling clips from", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 392, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 392, + 176, + 407 + ], + "score": 1.0, + "content": "easy to hard. Let", + "type": "text" + }, + { + "bbox": [ + 176, + 394, + 183, + 403 + ], + "score": 0.77, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 392, + 337, + 407 + ], + "score": 1.0, + "content": "be the shuffle degree of a shuffled clip", + "type": "text" + }, + { + "bbox": [ + 337, + 393, + 345, + 403 + ], + "score": 0.83, + "content": "\\widetilde { \\pmb x }", + "type": "inline_equation" + }, + { + "bbox": [ + 345, + 392, + 505, + 407 + ], + "score": 1.0, + "content": ", representing the number of continuous", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 404, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 307, + 416 + ], + "score": 1.0, + "content": "cuboids in each dimension. We gradually increase", + "type": "text" + }, + { + "bbox": [ + 307, + 405, + 313, + 414 + ], + "score": 0.78, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 404, + 505, + 416 + ], + "score": 1.0, + "content": "efrom 3 to 5 during the training phase to produce", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 415, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 505, + 428 + ], + "score": 1.0, + "content": "more permuted clips. Note that when the video content is ambiguous in one dimension, e.g., a static", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 426, + 506, + 439 + ], + "spans": [ + { + "bbox": [ + 106, + 426, + 506, + 439 + ], + "score": 1.0, + "content": "video clip inflated from an image, there is no temporal variance to learn the transformation. Kim", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 436, + 505, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 436, + 505, + 451 + ], + "score": 1.0, + "content": "et al. (2019); Noroozi & Favaro (2016) also mentioned this problem as similar-looking ambiguity.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 448, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 505, + 460 + ], + "score": 1.0, + "content": "To solve this problem, we calculate the variance on each dimension and set a threshold. If the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 459, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 106, + 459, + 304, + 471 + ], + "score": 1.0, + "content": "variance is lower than the threshold, we decrease", + "type": "text" + }, + { + "bbox": [ + 304, + 459, + 311, + 469 + ], + "score": 0.77, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 459, + 505, + 471 + ], + "score": 1.0, + "content": "from 3 to 1 so that the pieces are not shuffled in", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 470, + 226, + 482 + ], + "spans": [ + { + "bbox": [ + 106, + 470, + 226, + 482 + ], + "score": 1.0, + "content": "the corresponding dimension.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 381, + 506, + 482 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 493, + 302, + 506 + ], + "lines": [ + { + "bbox": [ + 105, + 493, + 304, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 304, + 508 + ], + "score": 1.0, + "content": "B DATASETS AND IMPLEMENTATION", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "title", + "bbox": [ + 108, + 514, + 231, + 526 + ], + "lines": [ + { + "bbox": [ + 106, + 514, + 232, + 526 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 232, + 526 + ], + "score": 1.0, + "content": "B.1 DETAILS OF DATASETS", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 535, + 505, + 579 + ], + "lines": [ + { + "bbox": [ + 105, + 535, + 505, + 548 + ], + "spans": [ + { + "bbox": [ + 105, + 535, + 505, + 548 + ], + "score": 1.0, + "content": "UCF101 (Soomro et al., 2012) is a widely-used dataset in the action recognition task, which contains", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 546, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 546, + 505, + 559 + ], + "score": 1.0, + "content": "13,320 videos with 101 action classes. The dataset is divided into three training/testing splits. In", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 556, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 506, + 570 + ], + "score": 1.0, + "content": "this paper, following prior works (Wang et al., 2020; Han et al., 2020), we use the first training split", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 568, + 370, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 568, + 370, + 581 + ], + "score": 1.0, + "content": "as the pre-training dataset and the first testing split for evaluation.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 535, + 506, + 581 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 585, + 505, + 629 + ], + "lines": [ + { + "bbox": [ + 105, + 585, + 505, + 597 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 505, + 597 + ], + "score": 1.0, + "content": "HMDB51 (Kuehne et al., 2011) is a relatively small action recognition dataset, consisting of 6,766", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 595, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 505, + 609 + ], + "score": 1.0, + "content": "videos with 51 categories. It is also divided into three training/testing splits. Following Wang et al.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 606, + 505, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 505, + 620 + ], + "score": 1.0, + "content": "(2020); Han et al. (2020), we use the first training split as the pre-training dataset and the first testing", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 618, + 186, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 186, + 630 + ], + "score": 1.0, + "content": "split for evaluation.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 585, + 505, + 630 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 634, + 505, + 668 + ], + "lines": [ + { + "bbox": [ + 105, + 633, + 505, + 648 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 505, + 648 + ], + "score": 1.0, + "content": "Kinetics-400 (K400) (Kay et al., 2017) is a very large action recognition dataset consisting of 400", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 646, + 504, + 658 + ], + "spans": [ + { + "bbox": [ + 106, + 646, + 504, + 658 + ], + "score": 1.0, + "content": "human action classes and around 306k videos. In this work, we use the training split of K400 as the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 658, + 189, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 189, + 669 + ], + "score": 1.0, + "content": "pre-training dataset.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34, + "bbox_fs": [ + 105, + 633, + 505, + 669 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 677, + 250, + 689 + ], + "lines": [ + { + "bbox": [ + 105, + 677, + 252, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 252, + 690 + ], + "score": 1.0, + "content": "B.2 IMPLEMENTATION DETAILS", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 36 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "In the fine-tuning stage, weights of convolutional layers are initialized with self-supervised pre-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 710, + 506, + 721 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 506, + 721 + ], + "score": 1.0, + "content": "training, but weights of fully-connected layers are randomly initialized. The whole network is then", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "trained with the cross-entropy loss. The pre-processing and training strategies are the same as in the", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 698, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 162, + 103, + 447, + 295 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 128, + 90, + 479, + 102 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 128, + 88, + 481, + 103 + ], + "spans": [ + { + "bbox": [ + 128, + 88, + 321, + 103 + ], + "score": 1.0, + "content": "Table 4: The structure of the encoding function", + "type": "text" + }, + { + "bbox": [ + 321, + 90, + 339, + 102 + ], + "score": 0.87, + "content": "f ( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 88, + 481, + 103 + ], + "score": 1.0, + "content": ". R2D3D-18 is used as an example.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 162, + 103, + 447, + 295 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 162, + 103, + 447, + 295 + ], + "spans": [ + { + "bbox": [ + 162, + 103, + 447, + 295 + ], + "score": 0.985, + "html": "
stagedetailoutput sizeT×HW×C
input data116×112²×3
conV11 × 7²,64stride 1, 2216 × 56² × 64
pool11 × 3²,64stride 1, 2216 × 28² × 64
res2[1 ×3²,641 × 3²,64×216 × 28² × 64
res31 × 3²,1281× 3²,128×216 × 14² × 128
res43× 3²,2563 × 32,256×28×7² × 256
res53 × 3²,512[3 × 3²,512×24 × 4² × 512
Avgpool4 × 4²,512stride 1,121 ×1² × 512
", + "type": "table", + "image_path": "6395e12e228509649ea9b03ca3209c0ad423368e2e47c7d7ea64e21a0954ee96.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 162, + 103, + 447, + 167.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 162, + 167.0, + 447, + 231.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 162, + 231.0, + 447, + 295.0 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "text", + "bbox": [ + 108, + 307, + 504, + 329 + ], + "lines": [ + { + "bbox": [ + 106, + 307, + 505, + 319 + ], + "spans": [ + { + "bbox": [ + 106, + 307, + 505, + 319 + ], + "score": 1.0, + "content": "self-supervised pre-training stage, except that the total epochs are 300 and the initial learning rate is", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 316, + 426, + 332 + ], + "spans": [ + { + "bbox": [ + 106, + 317, + 128, + 329 + ], + "score": 0.88, + "content": "1 0 ^ { - 3 }", + "type": "inline_equation" + }, + { + "bbox": [ + 128, + 316, + 426, + 332 + ], + "score": 1.0, + "content": ". We use a batch size of 64 per GPU and a total of 8 GPUs for fine-tuning.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 107, + 334, + 505, + 369 + ], + "lines": [ + { + "bbox": [ + 105, + 333, + 505, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 333, + 505, + 348 + ], + "score": 1.0, + "content": "We follow the standard evaluation protocol (Han et al., 2020) during inference and use ten-crop", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 345, + 505, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 505, + 358 + ], + "score": 1.0, + "content": "to take the same sequence length as training from the video. The predicted label of each video is", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 357, + 401, + 369 + ], + "spans": [ + { + "bbox": [ + 106, + 357, + 401, + 369 + ], + "score": 1.0, + "content": "calculated by averaging the softmax probabilities of all clips in the video.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7 + }, + { + "type": "title", + "bbox": [ + 108, + 380, + 267, + 393 + ], + "lines": [ + { + "bbox": [ + 105, + 378, + 268, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 268, + 395 + ], + "score": 1.0, + "content": "C NETWORK ARCHITECTURE", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 107, + 404, + 505, + 460 + ], + "lines": [ + { + "bbox": [ + 106, + 405, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 106, + 405, + 505, + 416 + ], + "score": 1.0, + "content": "We deploy the same network backbone R2D3D as Han et al. (2019; 2020), which is a 3D-ResNet", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 416, + 504, + 428 + ], + "spans": [ + { + "bbox": [ + 106, + 416, + 504, + 428 + ], + "score": 1.0, + "content": "(R3D) similar to Hara et al. (2018). The only difference between R2D3D and R3D lies in that:", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 426, + 504, + 438 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 504, + 438 + ], + "score": 1.0, + "content": "R2D3D keeps the first two residual blocks as 2D convolutional blocks while R3D uses 3D blocks.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 437, + 505, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 505, + 451 + ], + "score": 1.0, + "content": "Therefore, the modified R2D3D has fewer parameters (only the last two blocks are 3D convolutions).", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 448, + 318, + 462 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 318, + 462 + ], + "score": 1.0, + "content": "We present the CNN structure of R2D3D in Table 4.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12 + }, + { + "type": "title", + "bbox": [ + 107, + 473, + 300, + 486 + ], + "lines": [ + { + "bbox": [ + 105, + 471, + 302, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 302, + 488 + ], + "score": 1.0, + "content": "D ADDITIONAL ABLATION STUDIES", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "table", + "bbox": [ + 136, + 514, + 473, + 538 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 130, + 502, + 478, + 513 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 130, + 502, + 480, + 515 + ], + "spans": [ + { + "bbox": [ + 130, + 502, + 480, + 515 + ], + "score": 1.0, + "content": "Table 5: Evaluation of pre-training tasks under different designs of LCCD on UCF101.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "table_body", + "bbox": [ + 136, + 514, + 473, + 538 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 136, + 514, + 473, + 538 + ], + "spans": [ + { + "bbox": [ + 136, + 514, + 473, + 538 + ], + "score": 0.955, + "html": "
MethodsLCCSLCCD+MLccsLCCD + L1LCCD+MSE
Top-1 Acc66.564.066.567.8
", + "type": "table", + "image_path": "764e80fdb434f74d6e3d9fcada3c59a93671172bab4a6591b5e11c3813f58786.jpg" + } + ] + } + ], + "index": 17, + "virtual_lines": [ + { + "bbox": [ + 136, + 514, + 473, + 538 + ], + "spans": [], + "index": 17 + } + ] + } + ], + "index": 16.5 + }, + { + "type": "title", + "bbox": [ + 106, + 551, + 163, + 563 + ], + "lines": [ + { + "bbox": [ + 105, + 551, + 164, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 164, + 565 + ], + "score": 1.0, + "content": "D.1 LCCD", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 106, + 572, + 505, + 641 + ], + "lines": [ + { + "bbox": [ + 106, + 573, + 505, + 584 + ], + "spans": [ + { + "bbox": [ + 106, + 573, + 505, + 584 + ], + "score": 1.0, + "content": "Instead of predicting center points using the detection method, we also design a segmentation", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 583, + 504, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 583, + 504, + 595 + ], + "score": 1.0, + "content": "method – largest continuous cuboid segmentation (LCCS) to predicts the location of top-2 LCCs", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 107, + 591, + 507, + 610 + ], + "spans": [ + { + "bbox": [ + 107, + 594, + 189, + 607 + ], + "score": 0.91, + "content": "\\{ c _ { \\operatorname* { m a x } } ^ { \\mathrm { c o n t } } ( j ) : j = 1 , 2 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 591, + 507, + 610 + ], + "score": 1.0, + "content": ". The difference between LCCD and LCCS lies in that: LCCS is formulated as", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 103, + 602, + 507, + 622 + ], + "spans": [ + { + "bbox": [ + 103, + 602, + 392, + 622 + ], + "score": 1.0, + "content": "a segmentation task to discriminate whether a pixel is in the region of", + "type": "text" + }, + { + "bbox": [ + 392, + 605, + 423, + 618 + ], + "score": 0.92, + "content": "c _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } } ( j )", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 602, + 507, + 622 + ], + "score": 1.0, + "content": ". Concretely, LCCS", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 102, + 613, + 507, + 636 + ], + "spans": [ + { + "bbox": [ + 102, + 613, + 199, + 636 + ], + "score": 1.0, + "content": "predicts a binary mask", + "type": "text" + }, + { + "bbox": [ + 199, + 617, + 228, + 631 + ], + "score": 0.92, + "content": "M _ { \\mathrm { L C C S } } ^ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 613, + 366, + 636 + ], + "score": 1.0, + "content": "where only points in the region of", + "type": "text" + }, + { + "bbox": [ + 367, + 618, + 402, + 631 + ], + "score": 0.93, + "content": "\\{ c _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } } ( j )", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 613, + 507, + 636 + ], + "score": 1.0, + "content": "are set to be 1, otherwise", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 628, + 438, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 438, + 642 + ], + "score": 1.0, + "content": "0. As a result, LCCS is optimized using the Cross Entropy (CE) loss at each point:", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 21.5 + }, + { + "type": "interline_equation", + "bbox": [ + 205, + 645, + 405, + 674 + ], + "lines": [ + { + "bbox": [ + 205, + 645, + 405, + 674 + ], + "spans": [ + { + "bbox": [ + 205, + 645, + 405, + 674 + ], + "score": 0.93, + "content": "{ \\cal L } _ { \\mathrm { L C C S } } = \\sum _ { j \\in \\{ 1 , 2 \\} } \\sum _ { { \\pmb { a } } \\in { \\pmb { \\widetilde x } } } \\mathrm { C E } ( M _ { \\mathrm { L C C S } } ^ { j } ( { \\pmb { a } } ) , M _ { \\mathrm { L C C S } } ^ { j } ( { \\pmb { a } } ) ^ { ' } ) ,", + "type": "interline_equation", + "image_path": "65729811390c6767f78eff6db55e89f27571a0c184151c4f5bc16fcae3376658.jpg" + } + ] + } + ], + "index": 25.5, + "virtual_lines": [ + { + "bbox": [ + 205, + 645, + 405, + 659.5 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 205, + 659.5, + 405, + 674.0 + ], + "spans": [], + "index": 26 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 680, + 478, + 695 + ], + "lines": [ + { + "bbox": [ + 105, + 679, + 480, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 679, + 133, + 695 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 681, + 165, + 694 + ], + "score": 0.91, + "content": "\\operatorname { C E } ( \\cdot , \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 679, + 302, + 695 + ], + "score": 1.0, + "content": "denotes the CE loss function, and", + "type": "text" + }, + { + "bbox": [ + 303, + 679, + 347, + 695 + ], + "score": 0.95, + "content": "M _ { \\mathrm { L C C S } } ^ { j } ( \\pmb { a } ) ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 348, + 679, + 468, + 695 + ], + "score": 1.0, + "content": "is the predicted class of pixel", + "type": "text" + }, + { + "bbox": [ + 468, + 684, + 475, + 691 + ], + "score": 0.73, + "content": "\\textbf { \\em a }", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 679, + 480, + 695 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 698, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "We report the performance of four different designs of LCCD in Table 5: (1) LCCS: LCCS is used", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 193, + 721 + ], + "score": 1.0, + "content": "instead of LCCD. (2)", + "type": "text" + }, + { + "bbox": [ + 194, + 710, + 254, + 721 + ], + "score": 0.56, + "content": "\\mathrm { L C C D } { + } M _ { \\mathrm { L C C S } }", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 709, + 340, + 721 + ], + "score": 1.0, + "content": ": The Gaussian mask", + "type": "text" + }, + { + "bbox": [ + 340, + 710, + 370, + 721 + ], + "score": 0.9, + "content": "M _ { \\mathrm { L C C D } }", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 709, + 505, + 721 + ], + "score": 1.0, + "content": "is substituted by the binary mask", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 107, + 720, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 107, + 721, + 135, + 732 + ], + "score": 0.9, + "content": "M _ { \\mathrm { L C C S } }", + "type": "inline_equation" + }, + { + "bbox": [ + 135, + 720, + 371, + 733 + ], + "score": 1.0, + "content": ", but the LCCD task is optimized using the MSE loss. (3)", + "type": "text" + }, + { + "bbox": [ + 372, + 721, + 423, + 731 + ], + "score": 0.7, + "content": "\\mathrm { L C C D + L 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 720, + 506, + 733 + ], + "score": 1.0, + "content": ": The LCCD task is", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29 + } + ], + "page_idx": 13, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "14", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 162, + 103, + 447, + 295 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 128, + 90, + 479, + 102 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 128, + 88, + 481, + 103 + ], + "spans": [ + { + "bbox": [ + 128, + 88, + 321, + 103 + ], + "score": 1.0, + "content": "Table 4: The structure of the encoding function", + "type": "text" + }, + { + "bbox": [ + 321, + 90, + 339, + 102 + ], + "score": 0.87, + "content": "f ( \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 88, + 481, + 103 + ], + "score": 1.0, + "content": ". R2D3D-18 is used as an example.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 162, + 103, + 447, + 295 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 162, + 103, + 447, + 295 + ], + "spans": [ + { + "bbox": [ + 162, + 103, + 447, + 295 + ], + "score": 0.985, + "html": "
stagedetailoutput sizeT×HW×C
input data116×112²×3
conV11 × 7²,64stride 1, 2216 × 56² × 64
pool11 × 3²,64stride 1, 2216 × 28² × 64
res2[1 ×3²,641 × 3²,64×216 × 28² × 64
res31 × 3²,1281× 3²,128×216 × 14² × 128
res43× 3²,2563 × 32,256×28×7² × 256
res53 × 3²,512[3 × 3²,512×24 × 4² × 512
Avgpool4 × 4²,512stride 1,121 ×1² × 512
", + "type": "table", + "image_path": "6395e12e228509649ea9b03ca3209c0ad423368e2e47c7d7ea64e21a0954ee96.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 162, + 103, + 447, + 167.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 162, + 167.0, + 447, + 231.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 162, + 231.0, + 447, + 295.0 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "text", + "bbox": [ + 108, + 307, + 504, + 329 + ], + "lines": [ + { + "bbox": [ + 106, + 307, + 505, + 319 + ], + "spans": [ + { + "bbox": [ + 106, + 307, + 505, + 319 + ], + "score": 1.0, + "content": "self-supervised pre-training stage, except that the total epochs are 300 and the initial learning rate is", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 316, + 426, + 332 + ], + "spans": [ + { + "bbox": [ + 106, + 317, + 128, + 329 + ], + "score": 0.88, + "content": "1 0 ^ { - 3 }", + "type": "inline_equation" + }, + { + "bbox": [ + 128, + 316, + 426, + 332 + ], + "score": 1.0, + "content": ". We use a batch size of 64 per GPU and a total of 8 GPUs for fine-tuning.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5, + "bbox_fs": [ + 106, + 307, + 505, + 332 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 334, + 505, + 369 + ], + "lines": [ + { + "bbox": [ + 105, + 333, + 505, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 333, + 505, + 348 + ], + "score": 1.0, + "content": "We follow the standard evaluation protocol (Han et al., 2020) during inference and use ten-crop", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 345, + 505, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 505, + 358 + ], + "score": 1.0, + "content": "to take the same sequence length as training from the video. The predicted label of each video is", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 357, + 401, + 369 + ], + "spans": [ + { + "bbox": [ + 106, + 357, + 401, + 369 + ], + "score": 1.0, + "content": "calculated by averaging the softmax probabilities of all clips in the video.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7, + "bbox_fs": [ + 105, + 333, + 505, + 369 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 380, + 267, + 393 + ], + "lines": [ + { + "bbox": [ + 105, + 378, + 268, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 268, + 395 + ], + "score": 1.0, + "content": "C NETWORK ARCHITECTURE", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 107, + 404, + 505, + 460 + ], + "lines": [ + { + "bbox": [ + 106, + 405, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 106, + 405, + 505, + 416 + ], + "score": 1.0, + "content": "We deploy the same network backbone R2D3D as Han et al. (2019; 2020), which is a 3D-ResNet", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 416, + 504, + 428 + ], + "spans": [ + { + "bbox": [ + 106, + 416, + 504, + 428 + ], + "score": 1.0, + "content": "(R3D) similar to Hara et al. (2018). The only difference between R2D3D and R3D lies in that:", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 426, + 504, + 438 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 504, + 438 + ], + "score": 1.0, + "content": "R2D3D keeps the first two residual blocks as 2D convolutional blocks while R3D uses 3D blocks.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 437, + 505, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 505, + 451 + ], + "score": 1.0, + "content": "Therefore, the modified R2D3D has fewer parameters (only the last two blocks are 3D convolutions).", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 448, + 318, + 462 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 318, + 462 + ], + "score": 1.0, + "content": "We present the CNN structure of R2D3D in Table 4.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 405, + 505, + 462 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 473, + 300, + 486 + ], + "lines": [ + { + "bbox": [ + 105, + 471, + 302, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 302, + 488 + ], + "score": 1.0, + "content": "D ADDITIONAL ABLATION STUDIES", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "table", + "bbox": [ + 136, + 514, + 473, + 538 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 130, + 502, + 478, + 513 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 130, + 502, + 480, + 515 + ], + "spans": [ + { + "bbox": [ + 130, + 502, + 480, + 515 + ], + "score": 1.0, + "content": "Table 5: Evaluation of pre-training tasks under different designs of LCCD on UCF101.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "table_body", + "bbox": [ + 136, + 514, + 473, + 538 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 136, + 514, + 473, + 538 + ], + "spans": [ + { + "bbox": [ + 136, + 514, + 473, + 538 + ], + "score": 0.955, + "html": "
MethodsLCCSLCCD+MLccsLCCD + L1LCCD+MSE
Top-1 Acc66.564.066.567.8
", + "type": "table", + "image_path": "764e80fdb434f74d6e3d9fcada3c59a93671172bab4a6591b5e11c3813f58786.jpg" + } + ] + } + ], + "index": 17, + "virtual_lines": [ + { + "bbox": [ + 136, + 514, + 473, + 538 + ], + "spans": [], + "index": 17 + } + ] + } + ], + "index": 16.5 + }, + { + "type": "title", + "bbox": [ + 106, + 551, + 163, + 563 + ], + "lines": [ + { + "bbox": [ + 105, + 551, + 164, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 164, + 565 + ], + "score": 1.0, + "content": "D.1 LCCD", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 106, + 572, + 505, + 641 + ], + "lines": [ + { + "bbox": [ + 106, + 573, + 505, + 584 + ], + "spans": [ + { + "bbox": [ + 106, + 573, + 505, + 584 + ], + "score": 1.0, + "content": "Instead of predicting center points using the detection method, we also design a segmentation", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 583, + 504, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 583, + 504, + 595 + ], + "score": 1.0, + "content": "method – largest continuous cuboid segmentation (LCCS) to predicts the location of top-2 LCCs", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 107, + 591, + 507, + 610 + ], + "spans": [ + { + "bbox": [ + 107, + 594, + 189, + 607 + ], + "score": 0.91, + "content": "\\{ c _ { \\operatorname* { m a x } } ^ { \\mathrm { c o n t } } ( j ) : j = 1 , 2 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 591, + 507, + 610 + ], + "score": 1.0, + "content": ". The difference between LCCD and LCCS lies in that: LCCS is formulated as", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 103, + 602, + 507, + 622 + ], + "spans": [ + { + "bbox": [ + 103, + 602, + 392, + 622 + ], + "score": 1.0, + "content": "a segmentation task to discriminate whether a pixel is in the region of", + "type": "text" + }, + { + "bbox": [ + 392, + 605, + 423, + 618 + ], + "score": 0.92, + "content": "c _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } } ( j )", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 602, + 507, + 622 + ], + "score": 1.0, + "content": ". Concretely, LCCS", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 102, + 613, + 507, + 636 + ], + "spans": [ + { + "bbox": [ + 102, + 613, + 199, + 636 + ], + "score": 1.0, + "content": "predicts a binary mask", + "type": "text" + }, + { + "bbox": [ + 199, + 617, + 228, + 631 + ], + "score": 0.92, + "content": "M _ { \\mathrm { L C C S } } ^ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 613, + 366, + 636 + ], + "score": 1.0, + "content": "where only points in the region of", + "type": "text" + }, + { + "bbox": [ + 367, + 618, + 402, + 631 + ], + "score": 0.93, + "content": "\\{ c _ { \\mathrm { m a x } } ^ { \\mathrm { c o n t } } ( j )", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 613, + 507, + 636 + ], + "score": 1.0, + "content": "are set to be 1, otherwise", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 628, + 438, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 438, + 642 + ], + "score": 1.0, + "content": "0. As a result, LCCS is optimized using the Cross Entropy (CE) loss at each point:", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 21.5, + "bbox_fs": [ + 102, + 573, + 507, + 642 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 205, + 645, + 405, + 674 + ], + "lines": [ + { + "bbox": [ + 205, + 645, + 405, + 674 + ], + "spans": [ + { + "bbox": [ + 205, + 645, + 405, + 674 + ], + "score": 0.93, + "content": "{ \\cal L } _ { \\mathrm { L C C S } } = \\sum _ { j \\in \\{ 1 , 2 \\} } \\sum _ { { \\pmb { a } } \\in { \\pmb { \\widetilde x } } } \\mathrm { C E } ( M _ { \\mathrm { L C C S } } ^ { j } ( { \\pmb { a } } ) , M _ { \\mathrm { L C C S } } ^ { j } ( { \\pmb { a } } ) ^ { ' } ) ,", + "type": "interline_equation", + "image_path": "65729811390c6767f78eff6db55e89f27571a0c184151c4f5bc16fcae3376658.jpg" + } + ] + } + ], + "index": 25.5, + "virtual_lines": [ + { + "bbox": [ + 205, + 645, + 405, + 659.5 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 205, + 659.5, + 405, + 674.0 + ], + "spans": [], + "index": 26 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 680, + 478, + 695 + ], + "lines": [ + { + "bbox": [ + 105, + 679, + 480, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 679, + 133, + 695 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 681, + 165, + 694 + ], + "score": 0.91, + "content": "\\operatorname { C E } ( \\cdot , \\cdot )", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 679, + 302, + 695 + ], + "score": 1.0, + "content": "denotes the CE loss function, and", + "type": "text" + }, + { + "bbox": [ + 303, + 679, + 347, + 695 + ], + "score": 0.95, + "content": "M _ { \\mathrm { L C C S } } ^ { j } ( \\pmb { a } ) ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 348, + 679, + 468, + 695 + ], + "score": 1.0, + "content": "is the predicted class of pixel", + "type": "text" + }, + { + "bbox": [ + 468, + 684, + 475, + 691 + ], + "score": 0.73, + "content": "\\textbf { \\em a }", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 679, + 480, + 695 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 679, + 480, + 695 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 698, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "We report the performance of four different designs of LCCD in Table 5: (1) LCCS: LCCS is used", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 193, + 721 + ], + "score": 1.0, + "content": "instead of LCCD. (2)", + "type": "text" + }, + { + "bbox": [ + 194, + 710, + 254, + 721 + ], + "score": 0.56, + "content": "\\mathrm { L C C D } { + } M _ { \\mathrm { L C C S } }", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 709, + 340, + 721 + ], + "score": 1.0, + "content": ": The Gaussian mask", + "type": "text" + }, + { + "bbox": [ + 340, + 710, + 370, + 721 + ], + "score": 0.9, + "content": "M _ { \\mathrm { L C C D } }", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 709, + 505, + 721 + ], + "score": 1.0, + "content": "is substituted by the binary mask", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 107, + 720, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 107, + 721, + 135, + 732 + ], + "score": 0.9, + "content": "M _ { \\mathrm { L C C S } }", + "type": "inline_equation" + }, + { + "bbox": [ + 135, + 720, + 371, + 733 + ], + "score": 1.0, + "content": ", but the LCCD task is optimized using the MSE loss. (3)", + "type": "text" + }, + { + "bbox": [ + 372, + 721, + 423, + 731 + ], + "score": 0.7, + "content": "\\mathrm { L C C D + L 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 720, + 506, + 733 + ], + "score": 1.0, + "content": ": The LCCD task is", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 226, + 95 + ], + "score": 1.0, + "content": "optimized by the L1 loss. (4)", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 226, + 83, + 286, + 93 + ], + "score": 0.84, + "content": "\\mathrm { L C C D + M S E }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 286, + 82, + 505, + 95 + ], + "score": 1.0, + "content": ": The LCCD task is optimized by the MSE loss. From", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 92, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 92, + 505, + 107 + ], + "score": 1.0, + "content": "Table 5, it can be seen that the segmentation task also helps self-supervised representation learning", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "score": 1.0, + "content": "but doesn’t perform as well as LCCD. Also, under the three different settings of LCCD, the MSE", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 116, + 292, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 116, + 292, + 128 + ], + "score": 1.0, + "content": "loss with the Gaussian map performs the best.", + "type": "text", + "cross_page": true + } + ], + "index": 3 + } + ], + "index": 29, + "bbox_fs": [ + 106, + 698, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 127 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 226, + 95 + ], + "score": 1.0, + "content": "optimized by the L1 loss. (4)", + "type": "text" + }, + { + "bbox": [ + 226, + 83, + 286, + 93 + ], + "score": 0.84, + "content": "\\mathrm { L C C D + M S E }", + "type": "inline_equation" + }, + { + "bbox": [ + 286, + 82, + 505, + 95 + ], + "score": 1.0, + "content": ": The LCCD task is optimized by the MSE loss. From", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 92, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 92, + 505, + 107 + ], + "score": 1.0, + "content": "Table 5, it can be seen that the segmentation task also helps self-supervised representation learning", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "score": 1.0, + "content": "but doesn’t perform as well as LCCD. Also, under the three different settings of LCCD, the MSE", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 116, + 292, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 116, + 292, + 128 + ], + "score": 1.0, + "content": "loss with the Gaussian map performs the best.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "table", + "bbox": [ + 146, + 154, + 465, + 178 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 166, + 142, + 447, + 153 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 165, + 141, + 445, + 155 + ], + "spans": [ + { + "bbox": [ + 165, + 141, + 344, + 155 + ], + "score": 1.0, + "content": "Table 6: Evaluation of different temperature", + "type": "text" + }, + { + "bbox": [ + 344, + 145, + 351, + 152 + ], + "score": 0.75, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 141, + 445, + 155 + ], + "score": 1.0, + "content": "for CLSC on UCF101.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "table_body", + "bbox": [ + 146, + 154, + 465, + 178 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 146, + 154, + 465, + 178 + ], + "spans": [ + { + "bbox": [ + 146, + 154, + 465, + 178 + ], + "score": 0.96, + "html": "
MethodsT=1T =0.1T = 0.07
Top-1 Acc60.966.368.1
", + "type": "table", + "image_path": "80be8980029128ba9a8eca4f8b1c7f34d9c51f776c64fcc4d46250a5b4df8ce1.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 146, + 154, + 465, + 178 + ], + "spans": [], + "index": 5 + } + ] + } + ], + "index": 4.5 + }, + { + "type": "title", + "bbox": [ + 107, + 192, + 162, + 204 + ], + "lines": [ + { + "bbox": [ + 105, + 191, + 163, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 163, + 207 + ], + "score": 1.0, + "content": "D.2 CLSC", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 213, + 504, + 247 + ], + "lines": [ + { + "bbox": [ + 105, + 212, + 506, + 226 + ], + "spans": [ + { + "bbox": [ + 105, + 212, + 395, + 226 + ], + "score": 1.0, + "content": "Table 6 above shows the accuracies obtained with different temperatures", + "type": "text" + }, + { + "bbox": [ + 395, + 216, + 402, + 223 + ], + "score": 0.73, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 403, + 212, + 506, + 226 + ], + "score": 1.0, + "content": "used in contrastive learn-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 225, + 505, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 252, + 237 + ], + "score": 1.0, + "content": "ing. We can observe that: (1) When", + "type": "text" + }, + { + "bbox": [ + 253, + 227, + 260, + 235 + ], + "score": 0.74, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 225, + 320, + 237 + ], + "score": 1.0, + "content": "is in the range", + "type": "text" + }, + { + "bbox": [ + 320, + 225, + 357, + 235 + ], + "score": 0.89, + "content": "1 \\sim 0 . 0 7", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 225, + 505, + 237 + ], + "score": 1.0, + "content": ", the accuracy increases with smaller", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 235, + 477, + 249 + ], + "spans": [ + { + "bbox": [ + 106, + 237, + 113, + 245 + ], + "score": 0.66, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 235, + 158, + 249 + ], + "score": 1.0, + "content": ". (2) When", + "type": "text" + }, + { + "bbox": [ + 158, + 237, + 165, + 245 + ], + "score": 0.74, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 235, + 418, + 249 + ], + "score": 1.0, + "content": "is large (e.g., 1), the accuracy drops considerably. In this work,", + "type": "text" + }, + { + "bbox": [ + 419, + 237, + 426, + 245 + ], + "score": 0.74, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 235, + 477, + 249 + ], + "score": 1.0, + "content": "is set to 0.0.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8 + }, + { + "type": "table", + "bbox": [ + 148, + 274, + 460, + 298 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 180, + 263, + 428, + 273 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 180, + 262, + 431, + 275 + ], + "spans": [ + { + "bbox": [ + 180, + 262, + 431, + 275 + ], + "score": 1.0, + "content": "Table 7: Evaluation of different designs of CSPC on UCF101.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "table_body", + "bbox": [ + 148, + 274, + 460, + 298 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 148, + 274, + 460, + 298 + ], + "spans": [ + { + "bbox": [ + 148, + 274, + 460, + 298 + ], + "score": 0.954, + "html": "
Methods2 Categories4 Categories8 Categories
Top-1 Acc67.068.068.1
", + "type": "table", + "image_path": "0cff68af1bd53ea6d1e635dfc61e1f70415ab164ccb41a19165abbdb75aef1cf.jpg" + } + ] + } + ], + "index": 11, + "virtual_lines": [ + { + "bbox": [ + 148, + 274, + 460, + 298 + ], + "spans": [], + "index": 11 + } + ] + } + ], + "index": 10.5 + }, + { + "type": "title", + "bbox": [ + 106, + 313, + 161, + 324 + ], + "lines": [ + { + "bbox": [ + 105, + 311, + 162, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 311, + 162, + 327 + ], + "score": 1.0, + "content": "D.3 CSPC", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 333, + 505, + 411 + ], + "lines": [ + { + "bbox": [ + 105, + 334, + 505, + 346 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 505, + 346 + ], + "score": 1.0, + "content": "In addition to our CSPC with 8 pattern categories (see Sec. 3.3), we consider another two designs:", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 345, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 106, + 345, + 505, + 357 + ], + "score": 1.0, + "content": "(1) 2 Categories: the shuffled clip is discriminated by whether it has the same relative order of the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 356, + 506, + 368 + ], + "spans": [ + { + "bbox": [ + 106, + 356, + 506, + 368 + ], + "score": 1.0, + "content": "top-2 LCCs as the raw clip. It is almost the same as CLSC but is optimized by the CE loss. (2) 4", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 365, + 506, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 365, + 506, + 380 + ], + "score": 1.0, + "content": "Categories: the shuffled clip is discriminated by how it differs from the raw clip: non-difference,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 378, + 506, + 390 + ], + "spans": [ + { + "bbox": [ + 104, + 378, + 506, + 390 + ], + "score": 1.0, + "content": "spatial-only difference, temporal-only difference, spatiotemporal difference. From Table 7, we can", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 389, + 505, + 401 + ], + "spans": [ + { + "bbox": [ + 106, + 389, + 505, + 401 + ], + "score": 1.0, + "content": "see that CSPC with 8 categories outperforms the other two designs. These results support our moti-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 400, + 322, + 413 + ], + "spans": [ + { + "bbox": [ + 106, + 400, + 322, + 413 + ], + "score": 1.0, + "content": "vation for leveraging spatiotemporal transformations.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 16 + }, + { + "type": "table", + "bbox": [ + 154, + 437, + 455, + 462 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 178, + 426, + 432, + 437 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 178, + 426, + 433, + 438 + ], + "spans": [ + { + "bbox": [ + 178, + 426, + 433, + 438 + ], + "score": 1.0, + "content": "Table 8: Evaluation of different designs of CCMR on UCF101.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "table_body", + "bbox": [ + 154, + 437, + 455, + 462 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 154, + 437, + 455, + 462 + ], + "spans": [ + { + "bbox": [ + 154, + 437, + 455, + 462 + ], + "score": 0.969, + "html": "
Methodsldhdld+hd
Top-1 Acc66.967.268.1
", + "type": "table", + "image_path": "e6076bdfe8b2af58487f62f3115a3c6e1293babc7551660dfd82985183bce4f1.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 154, + 437, + 455, + 462 + ], + "spans": [], + "index": 21 + } + ] + } + ], + "index": 20.5 + }, + { + "type": "title", + "bbox": [ + 106, + 480, + 165, + 492 + ], + "lines": [ + { + "bbox": [ + 105, + 479, + 166, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 479, + 166, + 494 + ], + "score": 1.0, + "content": "D.4 CCMR", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 501, + 505, + 569 + ], + "lines": [ + { + "bbox": [ + 106, + 501, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 106, + 501, + 464, + 514 + ], + "score": 1.0, + "content": "We report the performance of three different designs of CCMR: (1) ld: the learning degree", + "type": "text" + }, + { + "bbox": [ + 464, + 502, + 475, + 513 + ], + "score": 0.87, + "content": "l _ { \\mathrm { l d } }", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 501, + 505, + 514 + ], + "score": 1.0, + "content": "is used", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 102, + 508, + 504, + 537 + ], + "spans": [ + { + "bbox": [ + 102, + 508, + 362, + 537 + ], + "score": 1.0, + "content": "as supervision, which only contains volume information. (2) hdare used, which contain only the relative order information. (3)", + "type": "text" + }, + { + "bbox": [ + 393, + 508, + 462, + 537 + ], + "score": 1.0, + "content": "mming distances : both ld and hd", + "type": "text" + }, + { + "bbox": [ + 462, + 513, + 504, + 525 + ], + "score": 0.71, + "content": "l _ { \\mathrm { h d } } ^ { \\mathrm { t } } , l _ { \\mathrm { h d } } ^ { \\mathrm { h } } , l _ { \\mathrm { h d } } ^ { \\mathrm { w } }", + "type": "inline_equation" + } + ], + "index": 24 + }, + { + "bbox": [ + 362, + 525, + 393, + 535 + ], + "spans": [ + { + "bbox": [ + 362, + 525, + 393, + 535 + ], + "score": 0.41, + "content": "\\mathrm { l d } + \\mathrm { h d }", + "type": "inline_equation" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 535, + 505, + 548 + ], + "spans": [ + { + "bbox": [ + 105, + 535, + 505, + 548 + ], + "score": 1.0, + "content": "supervision. From Table 8, we can see that: First, both ld and hd help the model to learn continuous", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 547, + 504, + 558 + ], + "spans": [ + { + "bbox": [ + 106, + 547, + 504, + 558 + ], + "score": 1.0, + "content": "characteristics during pre-training, and hd outperforms ld by a small margin. Second, our CCMR", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 558, + 325, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 558, + 325, + 569 + ], + "score": 1.0, + "content": "learns the best representation by combining ld and hd.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 25.5 + }, + { + "type": "title", + "bbox": [ + 108, + 582, + 294, + 593 + ], + "lines": [ + { + "bbox": [ + 106, + 582, + 294, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 582, + 294, + 595 + ], + "score": 1.0, + "content": "D.5 RESULTS OF DIRECTLY SOLVING CSJ", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 602, + 505, + 669 + ], + "lines": [ + { + "bbox": [ + 106, + 602, + 506, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 602, + 506, + 615 + ], + "score": 1.0, + "content": "We also demonstrate the results of solving the CSJ task directly in Table 9. We randomly shuffle", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 613, + 506, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 171, + 626 + ], + "score": 1.0, + "content": "video clips into", + "type": "text" + }, + { + "bbox": [ + 171, + 614, + 214, + 624 + ], + "score": 0.91, + "content": "4 \\times 4 \\times 4", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 613, + 506, + 626 + ], + "score": 1.0, + "content": "jigsaw puzzles. To recognize the correct permutation, the model solve a", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 108, + 624, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 108, + 625, + 163, + 636 + ], + "score": 0.87, + "content": "( 4 ! \\times 4 ! \\times 4 ! )", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 624, + 506, + 637 + ], + "score": 1.0, + "content": "-way classification task in the pre-training stage. We compare the CSJ task with the", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 635, + 506, + 648 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 506, + 648 + ], + "score": 1.0, + "content": "joint LCCD+CCMR task under the same setting for fair comparison. Linear evaluation is adopted to", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 646, + 505, + 659 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 468, + 659 + ], + "score": 1.0, + "content": "show the effectiveness of different tasks. We can observe from the table that solving LCCD", + "type": "text" + }, + { + "bbox": [ + 469, + 648, + 475, + 657 + ], + "score": 0.27, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 646, + 505, + 659 + ], + "score": 1.0, + "content": "CCMR", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 657, + 309, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 309, + 670 + ], + "score": 1.0, + "content": "jointly is more effective than solving CSJ directly.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 32.5 + }, + { + "type": "title", + "bbox": [ + 107, + 685, + 314, + 698 + ], + "lines": [ + { + "bbox": [ + 105, + 684, + 316, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 684, + 316, + 699 + ], + "score": 1.0, + "content": "E TEMPORAL ACTION SEGMENTATION", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 36 + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 708, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 708, + 505, + 721 + ], + "score": 1.0, + "content": "To show the effectiveness of our CSJ for solving new downstream tasks, we apply the pretrained", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 721, + 504, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 504, + 732 + ], + "score": 1.0, + "content": "model obtained by our CSJ to temporal action segmentation, which is more challenging than the", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37.5 + } + ], + "page_idx": 14, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 301, + 751, + 311, + 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, + 127 + ], + "lines": [], + "index": 1.5, + "bbox_fs": [ + 105, + 82, + 506, + 128 + ], + "lines_deleted": true + }, + { + "type": "table", + "bbox": [ + 146, + 154, + 465, + 178 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 166, + 142, + 447, + 153 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 165, + 141, + 445, + 155 + ], + "spans": [ + { + "bbox": [ + 165, + 141, + 344, + 155 + ], + "score": 1.0, + "content": "Table 6: Evaluation of different temperature", + "type": "text" + }, + { + "bbox": [ + 344, + 145, + 351, + 152 + ], + "score": 0.75, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 141, + 445, + 155 + ], + "score": 1.0, + "content": "for CLSC on UCF101.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "table_body", + "bbox": [ + 146, + 154, + 465, + 178 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 146, + 154, + 465, + 178 + ], + "spans": [ + { + "bbox": [ + 146, + 154, + 465, + 178 + ], + "score": 0.96, + "html": "
MethodsT=1T =0.1T = 0.07
Top-1 Acc60.966.368.1
", + "type": "table", + "image_path": "80be8980029128ba9a8eca4f8b1c7f34d9c51f776c64fcc4d46250a5b4df8ce1.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 146, + 154, + 465, + 178 + ], + "spans": [], + "index": 5 + } + ] + } + ], + "index": 4.5 + }, + { + "type": "title", + "bbox": [ + 107, + 192, + 162, + 204 + ], + "lines": [ + { + "bbox": [ + 105, + 191, + 163, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 163, + 207 + ], + "score": 1.0, + "content": "D.2 CLSC", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 213, + 504, + 247 + ], + "lines": [ + { + "bbox": [ + 105, + 212, + 506, + 226 + ], + "spans": [ + { + "bbox": [ + 105, + 212, + 395, + 226 + ], + "score": 1.0, + "content": "Table 6 above shows the accuracies obtained with different temperatures", + "type": "text" + }, + { + "bbox": [ + 395, + 216, + 402, + 223 + ], + "score": 0.73, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 403, + 212, + 506, + 226 + ], + "score": 1.0, + "content": "used in contrastive learn-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 225, + 505, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 252, + 237 + ], + "score": 1.0, + "content": "ing. We can observe that: (1) When", + "type": "text" + }, + { + "bbox": [ + 253, + 227, + 260, + 235 + ], + "score": 0.74, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 225, + 320, + 237 + ], + "score": 1.0, + "content": "is in the range", + "type": "text" + }, + { + "bbox": [ + 320, + 225, + 357, + 235 + ], + "score": 0.89, + "content": "1 \\sim 0 . 0 7", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 225, + 505, + 237 + ], + "score": 1.0, + "content": ", the accuracy increases with smaller", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 235, + 477, + 249 + ], + "spans": [ + { + "bbox": [ + 106, + 237, + 113, + 245 + ], + "score": 0.66, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 235, + 158, + 249 + ], + "score": 1.0, + "content": ". (2) When", + "type": "text" + }, + { + "bbox": [ + 158, + 237, + 165, + 245 + ], + "score": 0.74, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 235, + 418, + 249 + ], + "score": 1.0, + "content": "is large (e.g., 1), the accuracy drops considerably. In this work,", + "type": "text" + }, + { + "bbox": [ + 419, + 237, + 426, + 245 + ], + "score": 0.74, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 235, + 477, + 249 + ], + "score": 1.0, + "content": "is set to 0.0.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 212, + 506, + 249 + ] + }, + { + "type": "table", + "bbox": [ + 148, + 274, + 460, + 298 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 180, + 263, + 428, + 273 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 180, + 262, + 431, + 275 + ], + "spans": [ + { + "bbox": [ + 180, + 262, + 431, + 275 + ], + "score": 1.0, + "content": "Table 7: Evaluation of different designs of CSPC on UCF101.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "table_body", + "bbox": [ + 148, + 274, + 460, + 298 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 148, + 274, + 460, + 298 + ], + "spans": [ + { + "bbox": [ + 148, + 274, + 460, + 298 + ], + "score": 0.954, + "html": "
Methods2 Categories4 Categories8 Categories
Top-1 Acc67.068.068.1
", + "type": "table", + "image_path": "0cff68af1bd53ea6d1e635dfc61e1f70415ab164ccb41a19165abbdb75aef1cf.jpg" + } + ] + } + ], + "index": 11, + "virtual_lines": [ + { + "bbox": [ + 148, + 274, + 460, + 298 + ], + "spans": [], + "index": 11 + } + ] + } + ], + "index": 10.5 + }, + { + "type": "title", + "bbox": [ + 106, + 313, + 161, + 324 + ], + "lines": [ + { + "bbox": [ + 105, + 311, + 162, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 311, + 162, + 327 + ], + "score": 1.0, + "content": "D.3 CSPC", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 333, + 505, + 411 + ], + "lines": [ + { + "bbox": [ + 105, + 334, + 505, + 346 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 505, + 346 + ], + "score": 1.0, + "content": "In addition to our CSPC with 8 pattern categories (see Sec. 3.3), we consider another two designs:", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 345, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 106, + 345, + 505, + 357 + ], + "score": 1.0, + "content": "(1) 2 Categories: the shuffled clip is discriminated by whether it has the same relative order of the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 356, + 506, + 368 + ], + "spans": [ + { + "bbox": [ + 106, + 356, + 506, + 368 + ], + "score": 1.0, + "content": "top-2 LCCs as the raw clip. It is almost the same as CLSC but is optimized by the CE loss. (2) 4", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 365, + 506, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 365, + 506, + 380 + ], + "score": 1.0, + "content": "Categories: the shuffled clip is discriminated by how it differs from the raw clip: non-difference,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 378, + 506, + 390 + ], + "spans": [ + { + "bbox": [ + 104, + 378, + 506, + 390 + ], + "score": 1.0, + "content": "spatial-only difference, temporal-only difference, spatiotemporal difference. From Table 7, we can", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 389, + 505, + 401 + ], + "spans": [ + { + "bbox": [ + 106, + 389, + 505, + 401 + ], + "score": 1.0, + "content": "see that CSPC with 8 categories outperforms the other two designs. These results support our moti-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 400, + 322, + 413 + ], + "spans": [ + { + "bbox": [ + 106, + 400, + 322, + 413 + ], + "score": 1.0, + "content": "vation for leveraging spatiotemporal transformations.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 16, + "bbox_fs": [ + 104, + 334, + 506, + 413 + ] + }, + { + "type": "table", + "bbox": [ + 154, + 437, + 455, + 462 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 178, + 426, + 432, + 437 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 178, + 426, + 433, + 438 + ], + "spans": [ + { + "bbox": [ + 178, + 426, + 433, + 438 + ], + "score": 1.0, + "content": "Table 8: Evaluation of different designs of CCMR on UCF101.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "table_body", + "bbox": [ + 154, + 437, + 455, + 462 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 154, + 437, + 455, + 462 + ], + "spans": [ + { + "bbox": [ + 154, + 437, + 455, + 462 + ], + "score": 0.969, + "html": "
Methodsldhdld+hd
Top-1 Acc66.967.268.1
", + "type": "table", + "image_path": "e6076bdfe8b2af58487f62f3115a3c6e1293babc7551660dfd82985183bce4f1.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 154, + 437, + 455, + 462 + ], + "spans": [], + "index": 21 + } + ] + } + ], + "index": 20.5 + }, + { + "type": "title", + "bbox": [ + 106, + 480, + 165, + 492 + ], + "lines": [ + { + "bbox": [ + 105, + 479, + 166, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 479, + 166, + 494 + ], + "score": 1.0, + "content": "D.4 CCMR", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "list", + "bbox": [ + 107, + 501, + 505, + 569 + ], + "lines": [ + { + "bbox": [ + 106, + 501, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 106, + 501, + 464, + 514 + ], + "score": 1.0, + "content": "We report the performance of three different designs of CCMR: (1) ld: the learning degree", + "type": "text" + }, + { + "bbox": [ + 464, + 502, + 475, + 513 + ], + "score": 0.87, + "content": "l _ { \\mathrm { l d } }", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 501, + 505, + 514 + ], + "score": 1.0, + "content": "is used", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 102, + 508, + 504, + 537 + ], + "spans": [ + { + "bbox": [ + 102, + 508, + 362, + 537 + ], + "score": 1.0, + "content": "as supervision, which only contains volume information. (2) hdare used, which contain only the relative order information. (3)", + "type": "text" + }, + { + "bbox": [ + 393, + 508, + 462, + 537 + ], + "score": 1.0, + "content": "mming distances : both ld and hd", + "type": "text" + }, + { + "bbox": [ + 462, + 513, + 504, + 525 + ], + "score": 0.71, + "content": "l _ { \\mathrm { h d } } ^ { \\mathrm { t } } , l _ { \\mathrm { h d } } ^ { \\mathrm { h } } , l _ { \\mathrm { h d } } ^ { \\mathrm { w } }", + "type": "inline_equation" + } + ], + "index": 24 + }, + { + "bbox": [ + 362, + 525, + 393, + 535 + ], + "spans": [ + { + "bbox": [ + 362, + 525, + 393, + 535 + ], + "score": 0.41, + "content": "\\mathrm { l d } + \\mathrm { h d }", + "type": "inline_equation" + } + ], + "index": 25, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 535, + 505, + 548 + ], + "spans": [ + { + "bbox": [ + 105, + 535, + 505, + 548 + ], + "score": 1.0, + "content": "supervision. From Table 8, we can see that: First, both ld and hd help the model to learn continuous", + "type": "text" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 106, + 547, + 504, + 558 + ], + "spans": [ + { + "bbox": [ + 106, + 547, + 504, + 558 + ], + "score": 1.0, + "content": "characteristics during pre-training, and hd outperforms ld by a small margin. Second, our CCMR", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 558, + 325, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 558, + 325, + 569 + ], + "score": 1.0, + "content": "learns the best representation by combining ld and hd.", + "type": "text" + } + ], + "index": 28, + "is_list_end_line": true + } + ], + "index": 25.5, + "bbox_fs": [ + 102, + 501, + 505, + 569 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 582, + 294, + 593 + ], + "lines": [ + { + "bbox": [ + 106, + 582, + 294, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 582, + 294, + 595 + ], + "score": 1.0, + "content": "D.5 RESULTS OF DIRECTLY SOLVING CSJ", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 602, + 505, + 669 + ], + "lines": [ + { + "bbox": [ + 106, + 602, + 506, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 602, + 506, + 615 + ], + "score": 1.0, + "content": "We also demonstrate the results of solving the CSJ task directly in Table 9. We randomly shuffle", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 613, + 506, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 171, + 626 + ], + "score": 1.0, + "content": "video clips into", + "type": "text" + }, + { + "bbox": [ + 171, + 614, + 214, + 624 + ], + "score": 0.91, + "content": "4 \\times 4 \\times 4", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 613, + 506, + 626 + ], + "score": 1.0, + "content": "jigsaw puzzles. To recognize the correct permutation, the model solve a", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 108, + 624, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 108, + 625, + 163, + 636 + ], + "score": 0.87, + "content": "( 4 ! \\times 4 ! \\times 4 ! )", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 624, + 506, + 637 + ], + "score": 1.0, + "content": "-way classification task in the pre-training stage. We compare the CSJ task with the", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 635, + 506, + 648 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 506, + 648 + ], + "score": 1.0, + "content": "joint LCCD+CCMR task under the same setting for fair comparison. Linear evaluation is adopted to", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 646, + 505, + 659 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 468, + 659 + ], + "score": 1.0, + "content": "show the effectiveness of different tasks. We can observe from the table that solving LCCD", + "type": "text" + }, + { + "bbox": [ + 469, + 648, + 475, + 657 + ], + "score": 0.27, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 646, + 505, + 659 + ], + "score": 1.0, + "content": "CCMR", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 657, + 309, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 309, + 670 + ], + "score": 1.0, + "content": "jointly is more effective than solving CSJ directly.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 602, + 506, + 670 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 685, + 314, + 698 + ], + "lines": [ + { + "bbox": [ + 105, + 684, + 316, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 684, + 316, + 699 + ], + "score": 1.0, + "content": "E TEMPORAL ACTION SEGMENTATION", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 36 + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 708, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 708, + 505, + 721 + ], + "score": 1.0, + "content": "To show the effectiveness of our CSJ for solving new downstream tasks, we apply the pretrained", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 721, + 504, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 504, + 732 + ], + "score": 1.0, + "content": "model obtained by our CSJ to temporal action segmentation, which is more challenging than the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 498, + 505, + 510 + ], + "spans": [ + { + "bbox": [ + 106, + 498, + 505, + 510 + ], + "score": 1.0, + "content": "conventional action recognition and retrieval tasks. Specifically, we choose to compare our CSJ", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 508, + 505, + 521 + ], + "spans": [ + { + "bbox": [ + 105, + 508, + 505, + 521 + ], + "score": 1.0, + "content": "model with the latest competitor MemDPC (Han et al., 2020) on the Breakfast dataset (Kuehne", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 519, + 505, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 519, + 505, + 532 + ], + "score": 1.0, + "content": "et al., 2014). For fair comparison, our CSJ model and the MemDPC model adopt the same R2D3D-", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 530, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 505, + 543 + ], + "score": 1.0, + "content": "34 backbone. Due the time constraint, from the original Breakfast dataset, we only use a small", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 541, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 505, + 554 + ], + "score": 1.0, + "content": "subset of 200 long videos as the training set for fine-tuning, and select a few long videos for the test.", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 552, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 505, + 565 + ], + "score": 1.0, + "content": "For temporal action segmentation, we follow the overall framework of MS-TCN (Abu Farha & Gall,", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 563, + 440, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 440, + 577 + ], + "score": 1.0, + "content": "2019), but changes its backbone to R2D3D-34 pretrained by our CSJ or MemDPC.", + "type": "text", + "cross_page": true + } + ], + "index": 11 + } + ], + "index": 37.5, + "bbox_fs": [ + 106, + 708, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 108, + 112, + 501, + 439 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 112, + 501, + 439 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 112, + 501, + 439 + ], + "spans": [ + { + "bbox": [ + 108, + 112, + 501, + 439 + ], + "score": 0.953, + "type": "image", + "image_path": "91d5f16e4c3031f297cf0187ff6396d46e14d07e9f8ebd39a1ff3cfc677d685f.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 108, + 112, + 501, + 221.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 108, + 221.0, + 501, + 330.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 108, + 330.0, + 501, + 439.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 455, + 504, + 477 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 455, + 505, + 467 + ], + "spans": [ + { + "bbox": [ + 106, + 455, + 505, + 467 + ], + "score": 1.0, + "content": "Figure 5: Qualitative results for the temporal action segmentation task on the Breakfast dataset. Note", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 465, + 393, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 173, + 478 + ], + "score": 1.0, + "content": "that the notation", + "type": "text" + }, + { + "bbox": [ + 174, + 466, + 180, + 476 + ], + "score": 0.75, + "content": "\\varnothing", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 465, + 393, + 478 + ], + "score": 1.0, + "content": "denotes an unannotated segment in the ground truth.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 106, + 497, + 505, + 575 + ], + "lines": [ + { + "bbox": [ + 106, + 498, + 505, + 510 + ], + "spans": [ + { + "bbox": [ + 106, + 498, + 505, + 510 + ], + "score": 1.0, + "content": "conventional action recognition and retrieval tasks. Specifically, we choose to compare our CSJ", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 508, + 505, + 521 + ], + "spans": [ + { + "bbox": [ + 105, + 508, + 505, + 521 + ], + "score": 1.0, + "content": "model with the latest competitor MemDPC (Han et al., 2020) on the Breakfast dataset (Kuehne", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 519, + 505, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 519, + 505, + 532 + ], + "score": 1.0, + "content": "et al., 2014). For fair comparison, our CSJ model and the MemDPC model adopt the same R2D3D-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 530, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 505, + 543 + ], + "score": 1.0, + "content": "34 backbone. Due the time constraint, from the original Breakfast dataset, we only use a small", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 541, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 505, + 554 + ], + "score": 1.0, + "content": "subset of 200 long videos as the training set for fine-tuning, and select a few long videos for the test.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 552, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 505, + 565 + ], + "score": 1.0, + "content": "For temporal action segmentation, we follow the overall framework of MS-TCN (Abu Farha & Gall,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 563, + 440, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 440, + 577 + ], + "score": 1.0, + "content": "2019), but changes its backbone to R2D3D-34 pretrained by our CSJ or MemDPC.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 580, + 505, + 658 + ], + "lines": [ + { + "bbox": [ + 106, + 581, + 505, + 592 + ], + "spans": [ + { + "bbox": [ + 106, + 581, + 505, + 592 + ], + "score": 1.0, + "content": "We present the qualitative results on two test videos in Fig. 5. We can clearly observe that our CSJ", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 591, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 591, + 505, + 603 + ], + "score": 1.0, + "content": "outperforms MemDPC on both test videos. Particularly, the predictions of our CSJ are much closer", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 602, + 505, + 615 + ], + "spans": [ + { + "bbox": [ + 105, + 602, + 505, + 615 + ], + "score": 1.0, + "content": "to the ground truth, but MemDPC tends to produce unwanted segments for temporal action segmen-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 613, + 505, + 626 + ], + "spans": [ + { + "bbox": [ + 106, + 613, + 505, + 626 + ], + "score": 1.0, + "content": "tation: it wrongly recognizes the segment (color in yellow) in the middle part of the first video as", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 623, + 505, + 637 + ], + "spans": [ + { + "bbox": [ + 106, + 623, + 505, + 637 + ], + "score": 1.0, + "content": "‘Pour Milk’, and the segment (color in black) in the last part of the second video as ‘Stir Coffee’.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 635, + 505, + 648 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 505, + 648 + ], + "score": 1.0, + "content": "In conclusion, as compared to the latest SSVRL method MemDPC, our CSJ can learn more robust", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 645, + 490, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 490, + 660 + ], + "score": 1.0, + "content": "features for temporal action segmentation due to its ‘true’ spatiotemporal jigsaw understanding.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15 + } + ], + "page_idx": 15, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 307, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2021", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "16", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 108, + 112, + 501, + 439 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 112, + 501, + 439 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 112, + 501, + 439 + ], + "spans": [ + { + "bbox": [ + 108, + 112, + 501, + 439 + ], + "score": 0.953, + "type": "image", + "image_path": "91d5f16e4c3031f297cf0187ff6396d46e14d07e9f8ebd39a1ff3cfc677d685f.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 108, + 112, + 501, + 221.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 108, + 221.0, + 501, + 330.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 108, + 330.0, + 501, + 439.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 455, + 504, + 477 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 455, + 505, + 467 + ], + "spans": [ + { + "bbox": [ + 106, + 455, + 505, + 467 + ], + "score": 1.0, + "content": "Figure 5: Qualitative results for the temporal action segmentation task on the Breakfast dataset. Note", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 465, + 393, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 173, + 478 + ], + "score": 1.0, + "content": "that the notation", + "type": "text" + }, + { + "bbox": [ + 174, + 466, + 180, + 476 + ], + "score": 0.75, + "content": "\\varnothing", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 465, + 393, + 478 + ], + "score": 1.0, + "content": "denotes an unannotated segment in the ground truth.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 106, + 497, + 505, + 575 + ], + "lines": [], + "index": 8, + "bbox_fs": [ + 105, + 498, + 505, + 577 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 580, + 505, + 658 + ], + "lines": [ + { + "bbox": [ + 106, + 581, + 505, + 592 + ], + "spans": [ + { + "bbox": [ + 106, + 581, + 505, + 592 + ], + "score": 1.0, + "content": "We present the qualitative results on two test videos in Fig. 5. We can clearly observe that our CSJ", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 591, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 591, + 505, + 603 + ], + "score": 1.0, + "content": "outperforms MemDPC on both test videos. Particularly, the predictions of our CSJ are much closer", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 602, + 505, + 615 + ], + "spans": [ + { + "bbox": [ + 105, + 602, + 505, + 615 + ], + "score": 1.0, + "content": "to the ground truth, but MemDPC tends to produce unwanted segments for temporal action segmen-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 613, + 505, + 626 + ], + "spans": [ + { + "bbox": [ + 106, + 613, + 505, + 626 + ], + "score": 1.0, + "content": "tation: it wrongly recognizes the segment (color in yellow) in the middle part of the first video as", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 623, + 505, + 637 + ], + "spans": [ + { + "bbox": [ + 106, + 623, + 505, + 637 + ], + "score": 1.0, + "content": "‘Pour Milk’, and the segment (color in black) in the last part of the second video as ‘Stir Coffee’.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 635, + 505, + 648 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 505, + 648 + ], + "score": 1.0, + "content": "In conclusion, as compared to the latest SSVRL method MemDPC, our CSJ can learn more robust", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 645, + 490, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 490, + 660 + ], + "score": 1.0, + "content": "features for temporal action segmentation due to its ‘true’ spatiotemporal jigsaw understanding.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 581, + 505, + 660 + ] + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file