diff --git "a/parse/train/B12Js_yRb/B12Js_yRb_middle.json" "b/parse/train/B12Js_yRb/B12Js_yRb_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/B12Js_yRb/B12Js_yRb_middle.json" @@ -0,0 +1,39486 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 78, + 502, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 77, + 505, + 98 + ], + "spans": [ + { + "bbox": [ + 105, + 77, + 505, + 98 + ], + "score": 1.0, + "content": "LEARNING TO COUNT OBJECTS IN NATURAL IMAGES", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 104, + 98, + 381, + 119 + ], + "spans": [ + { + "bbox": [ + 104, + 98, + 381, + 119 + ], + "score": 1.0, + "content": "FOR VISUAL QUESTION ANSWERING", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 112, + 137, + 344, + 149 + ], + "lines": [ + { + "bbox": [ + 111, + 136, + 346, + 152 + ], + "spans": [ + { + "bbox": [ + 111, + 136, + 346, + 152 + ], + "score": 1.0, + "content": "Yan Zhang & Jonathon Hare & Adam Prugel-Bennett ¨", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 113, + 150, + 311, + 182 + ], + "lines": [ + { + "bbox": [ + 111, + 148, + 313, + 162 + ], + "spans": [ + { + "bbox": [ + 111, + 148, + 313, + 162 + ], + "score": 1.0, + "content": "Department of Electronics and Computer Science", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 112, + 160, + 223, + 171 + ], + "spans": [ + { + "bbox": [ + 112, + 160, + 223, + 171 + ], + "score": 1.0, + "content": "University of Southampton", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 113, + 171, + 310, + 183 + ], + "spans": [ + { + "bbox": [ + 113, + 171, + 310, + 183 + ], + "score": 1.0, + "content": "{yz5n12,jsh2,apb}@ecs.soton.ac.uk", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + }, + { + "type": "title", + "bbox": [ + 278, + 211, + 333, + 223 + ], + "lines": [ + { + "bbox": [ + 277, + 211, + 335, + 225 + ], + "spans": [ + { + "bbox": [ + 277, + 211, + 335, + 225 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 143, + 235, + 469, + 335 + ], + "lines": [ + { + "bbox": [ + 142, + 236, + 469, + 249 + ], + "spans": [ + { + "bbox": [ + 142, + 236, + 469, + 249 + ], + "score": 1.0, + "content": "Visual Question Answering (VQA) models have struggled with counting objects in", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 247, + 469, + 259 + ], + "spans": [ + { + "bbox": [ + 141, + 247, + 469, + 259 + ], + "score": 1.0, + "content": "natural images so far. We identify a fundamental problem due to soft attention in", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 258, + 470, + 271 + ], + "spans": [ + { + "bbox": [ + 141, + 258, + 470, + 271 + ], + "score": 1.0, + "content": "these models as a cause. To circumvent this problem, we propose a neural network", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 269, + 470, + 281 + ], + "spans": [ + { + "bbox": [ + 141, + 269, + 470, + 281 + ], + "score": 1.0, + "content": "component that allows robust counting from object proposals. Experiments on", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 280, + 470, + 292 + ], + "spans": [ + { + "bbox": [ + 141, + 280, + 470, + 292 + ], + "score": 1.0, + "content": "a toy task show the effectiveness of this component and we obtain state-of-the-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 291, + 470, + 303 + ], + "spans": [ + { + "bbox": [ + 141, + 291, + 470, + 303 + ], + "score": 1.0, + "content": "art accuracy on the number category of the VQA v2 dataset without negatively", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 142, + 302, + 470, + 314 + ], + "spans": [ + { + "bbox": [ + 142, + 302, + 470, + 314 + ], + "score": 1.0, + "content": "affecting other categories, even outperforming ensemble models with our single", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 312, + 469, + 325 + ], + "spans": [ + { + "bbox": [ + 141, + 312, + 469, + 325 + ], + "score": 1.0, + "content": "model. On a difficult balanced pair metric, the component gives a substantial", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 324, + 373, + 335 + ], + "spans": [ + { + "bbox": [ + 141, + 324, + 347, + 335 + ], + "score": 1.0, + "content": "improvement in counting over a strong baseline by", + "type": "text" + }, + { + "bbox": [ + 347, + 324, + 369, + 334 + ], + "score": 0.83, + "content": "6 . 6 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 324, + 373, + 335 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 11 + }, + { + "type": "title", + "bbox": [ + 108, + 354, + 206, + 367 + ], + "lines": [ + { + "bbox": [ + 105, + 353, + 208, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 208, + 371 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 379, + 505, + 446 + ], + "lines": [ + { + "bbox": [ + 106, + 380, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 505, + 392 + ], + "score": 1.0, + "content": "Consider the problem of counting how many cats there are in Figure 1. Solving this involves several", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 391, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 505, + 403 + ], + "score": 1.0, + "content": "rough steps: understanding what instances of that type can look like, finding them in the image, and", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 402, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 505, + 415 + ], + "score": 1.0, + "content": "adding them up. This is a common task in Visual Question Answering (VQA) – answering questions", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 412, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 506, + 426 + ], + "score": 1.0, + "content": "about images – and is rated as among the tasks requiring the lowest human age to be able to answer", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 423, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 505, + 437 + ], + "score": 1.0, + "content": "(Antol et al., 2015). However, current models for VQA on natural images struggle to answer any", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 435, + 412, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 412, + 447 + ], + "score": 1.0, + "content": "counting questions successfully outside of dataset biases (Jabri et al., 2016).", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 107, + 451, + 505, + 507 + ], + "lines": [ + { + "bbox": [ + 106, + 452, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 505, + 464 + ], + "score": 1.0, + "content": "One reason for this is the presence of a fundamental problem with counting in the widely-used soft", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 463, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 463, + 505, + 475 + ], + "score": 1.0, + "content": "attention mechanisms (section 3). Another reason is that unlike standard counting tasks, there is no", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 473, + 506, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 506, + 487 + ], + "score": 1.0, + "content": "ground truth labeling of where the objects to count are. Coupled with the fact that models need to", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 484, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 505, + 498 + ], + "score": 1.0, + "content": "be able to count a large variety of objects and that, ideally, performance on non-counting questions", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 494, + 435, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 435, + 510 + ], + "score": 1.0, + "content": "should not be compromised, the task of counting in VQA seems very challenging.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 107, + 512, + 505, + 557 + ], + "lines": [ + { + "bbox": [ + 105, + 511, + 507, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 507, + 525 + ], + "score": 1.0, + "content": "To make this task easier, we can use object proposals – pairs of a bounding box and object features –", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 523, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 505, + 536 + ], + "score": 1.0, + "content": "from object detection networks as input instead of learning from pixels directly. In any moderately", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 535, + 506, + 547 + ], + "spans": [ + { + "bbox": [ + 106, + 535, + 506, + 547 + ], + "score": 1.0, + "content": "complex scene, this runs into the issue of double-counting overlapping object proposals. This is a", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 546, + 506, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 506, + 558 + ], + "score": 1.0, + "content": "problem present in many natural images, which leads to inaccurate counting in real-world scenarios.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 107, + 562, + 505, + 651 + ], + "lines": [ + { + "bbox": [ + 106, + 562, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 106, + 562, + 505, + 574 + ], + "score": 1.0, + "content": "Our main contribution is a differentiable neural network component that tackles this problem and", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 574, + 506, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 506, + 586 + ], + "score": 1.0, + "content": "consequently can learn to count (section 4). Used alongside an attention mechanism, this component", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 585, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 505, + 596 + ], + "score": 1.0, + "content": "avoids a fundamental limitation of soft attention while producing strong counting features. We", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 595, + 507, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 507, + 608 + ], + "score": 1.0, + "content": "provide experimental evidence of the effectiveness of this component (section 5). On a toy dataset,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 607, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 106, + 607, + 505, + 618 + ], + "score": 1.0, + "content": "we demonstrate that this component enables robust counting in a variety of scenarios. On the number", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 617, + 506, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 506, + 630 + ], + "score": 1.0, + "content": "category of the VQA v2 Open-Ended dataset (Goyal et al., 2017), a relatively simple baseline model", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 628, + 506, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 506, + 641 + ], + "score": 1.0, + "content": "using the counting component outperforms all previous models – including large ensembles of", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 639, + 423, + 652 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 423, + 652 + ], + "score": 1.0, + "content": "state-of-the-art methods – without degrading performance on other categories.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 35.5 + }, + { + "type": "title", + "bbox": [ + 108, + 666, + 209, + 678 + ], + "lines": [ + { + "bbox": [ + 104, + 664, + 210, + 681 + ], + "spans": [ + { + "bbox": [ + 104, + 664, + 210, + 681 + ], + "score": 1.0, + "content": "2 RELATED WORK", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 108, + 691, + 505, + 713 + ], + "lines": [ + { + "bbox": [ + 107, + 691, + 506, + 704 + ], + "spans": [ + { + "bbox": [ + 107, + 691, + 506, + 704 + ], + "score": 1.0, + "content": "Usually, greedy non-maximum suppression (NMS) is used to eliminate duplicate bounding boxes.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 107, + 702, + 505, + 714 + ], + "spans": [ + { + "bbox": [ + 107, + 702, + 505, + 714 + ], + "score": 1.0, + "content": "The main problem with using it as part of a model is that its gradient is piecewise constant. Various", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 116, + 722, + 484, + 732 + ], + "lines": [ + { + "bbox": [ + 119, + 719, + 485, + 734 + ], + "spans": [ + { + "bbox": [ + 119, + 719, + 485, + 734 + ], + "score": 1.0, + "content": "1Our implementation is available at https://github.com/Cyanogenoid/vqa-counting.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 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": [ + 107, + 78, + 502, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 77, + 505, + 98 + ], + "spans": [ + { + "bbox": [ + 105, + 77, + 505, + 98 + ], + "score": 1.0, + "content": "LEARNING TO COUNT OBJECTS IN NATURAL IMAGES", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 104, + 98, + 381, + 119 + ], + "spans": [ + { + "bbox": [ + 104, + 98, + 381, + 119 + ], + "score": 1.0, + "content": "FOR VISUAL QUESTION ANSWERING", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 112, + 137, + 344, + 149 + ], + "lines": [ + { + "bbox": [ + 111, + 136, + 346, + 152 + ], + "spans": [ + { + "bbox": [ + 111, + 136, + 346, + 152 + ], + "score": 1.0, + "content": "Yan Zhang & Jonathon Hare & Adam Prugel-Bennett ¨", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2, + "bbox_fs": [ + 111, + 136, + 346, + 152 + ] + }, + { + "type": "text", + "bbox": [ + 113, + 150, + 311, + 182 + ], + "lines": [ + { + "bbox": [ + 111, + 148, + 313, + 162 + ], + "spans": [ + { + "bbox": [ + 111, + 148, + 313, + 162 + ], + "score": 1.0, + "content": "Department of Electronics and Computer Science", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 112, + 160, + 223, + 171 + ], + "spans": [ + { + "bbox": [ + 112, + 160, + 223, + 171 + ], + "score": 1.0, + "content": "University of Southampton", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 113, + 171, + 310, + 183 + ], + "spans": [ + { + "bbox": [ + 113, + 171, + 310, + 183 + ], + "score": 1.0, + "content": "{yz5n12,jsh2,apb}@ecs.soton.ac.uk", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4, + "bbox_fs": [ + 111, + 148, + 313, + 183 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 211, + 333, + 223 + ], + "lines": [ + { + "bbox": [ + 277, + 211, + 335, + 225 + ], + "spans": [ + { + "bbox": [ + 277, + 211, + 335, + 225 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 143, + 235, + 469, + 335 + ], + "lines": [ + { + "bbox": [ + 142, + 236, + 469, + 249 + ], + "spans": [ + { + "bbox": [ + 142, + 236, + 469, + 249 + ], + "score": 1.0, + "content": "Visual Question Answering (VQA) models have struggled with counting objects in", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 247, + 469, + 259 + ], + "spans": [ + { + "bbox": [ + 141, + 247, + 469, + 259 + ], + "score": 1.0, + "content": "natural images so far. We identify a fundamental problem due to soft attention in", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 258, + 470, + 271 + ], + "spans": [ + { + "bbox": [ + 141, + 258, + 470, + 271 + ], + "score": 1.0, + "content": "these models as a cause. To circumvent this problem, we propose a neural network", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 269, + 470, + 281 + ], + "spans": [ + { + "bbox": [ + 141, + 269, + 470, + 281 + ], + "score": 1.0, + "content": "component that allows robust counting from object proposals. Experiments on", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 280, + 470, + 292 + ], + "spans": [ + { + "bbox": [ + 141, + 280, + 470, + 292 + ], + "score": 1.0, + "content": "a toy task show the effectiveness of this component and we obtain state-of-the-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 291, + 470, + 303 + ], + "spans": [ + { + "bbox": [ + 141, + 291, + 470, + 303 + ], + "score": 1.0, + "content": "art accuracy on the number category of the VQA v2 dataset without negatively", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 142, + 302, + 470, + 314 + ], + "spans": [ + { + "bbox": [ + 142, + 302, + 470, + 314 + ], + "score": 1.0, + "content": "affecting other categories, even outperforming ensemble models with our single", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 312, + 469, + 325 + ], + "spans": [ + { + "bbox": [ + 141, + 312, + 469, + 325 + ], + "score": 1.0, + "content": "model. On a difficult balanced pair metric, the component gives a substantial", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 324, + 373, + 335 + ], + "spans": [ + { + "bbox": [ + 141, + 324, + 347, + 335 + ], + "score": 1.0, + "content": "improvement in counting over a strong baseline by", + "type": "text" + }, + { + "bbox": [ + 347, + 324, + 369, + 334 + ], + "score": 0.83, + "content": "6 . 6 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 324, + 373, + 335 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 11, + "bbox_fs": [ + 141, + 236, + 470, + 335 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 354, + 206, + 367 + ], + "lines": [ + { + "bbox": [ + 105, + 353, + 208, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 208, + 371 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 379, + 505, + 446 + ], + "lines": [ + { + "bbox": [ + 106, + 380, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 505, + 392 + ], + "score": 1.0, + "content": "Consider the problem of counting how many cats there are in Figure 1. Solving this involves several", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 391, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 505, + 403 + ], + "score": 1.0, + "content": "rough steps: understanding what instances of that type can look like, finding them in the image, and", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 402, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 505, + 415 + ], + "score": 1.0, + "content": "adding them up. This is a common task in Visual Question Answering (VQA) – answering questions", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 412, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 506, + 426 + ], + "score": 1.0, + "content": "about images – and is rated as among the tasks requiring the lowest human age to be able to answer", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 423, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 505, + 437 + ], + "score": 1.0, + "content": "(Antol et al., 2015). However, current models for VQA on natural images struggle to answer any", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 435, + 412, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 412, + 447 + ], + "score": 1.0, + "content": "counting questions successfully outside of dataset biases (Jabri et al., 2016).", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 380, + 506, + 447 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 451, + 505, + 507 + ], + "lines": [ + { + "bbox": [ + 106, + 452, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 505, + 464 + ], + "score": 1.0, + "content": "One reason for this is the presence of a fundamental problem with counting in the widely-used soft", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 463, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 463, + 505, + 475 + ], + "score": 1.0, + "content": "attention mechanisms (section 3). Another reason is that unlike standard counting tasks, there is no", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 473, + 506, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 506, + 487 + ], + "score": 1.0, + "content": "ground truth labeling of where the objects to count are. Coupled with the fact that models need to", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 484, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 505, + 498 + ], + "score": 1.0, + "content": "be able to count a large variety of objects and that, ideally, performance on non-counting questions", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 494, + 435, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 435, + 510 + ], + "score": 1.0, + "content": "should not be compromised, the task of counting in VQA seems very challenging.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 452, + 506, + 510 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 512, + 505, + 557 + ], + "lines": [ + { + "bbox": [ + 105, + 511, + 507, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 507, + 525 + ], + "score": 1.0, + "content": "To make this task easier, we can use object proposals – pairs of a bounding box and object features –", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 523, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 505, + 536 + ], + "score": 1.0, + "content": "from object detection networks as input instead of learning from pixels directly. In any moderately", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 535, + 506, + 547 + ], + "spans": [ + { + "bbox": [ + 106, + 535, + 506, + 547 + ], + "score": 1.0, + "content": "complex scene, this runs into the issue of double-counting overlapping object proposals. This is a", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 546, + 506, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 506, + 558 + ], + "score": 1.0, + "content": "problem present in many natural images, which leads to inaccurate counting in real-world scenarios.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5, + "bbox_fs": [ + 105, + 511, + 507, + 558 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 562, + 505, + 651 + ], + "lines": [ + { + "bbox": [ + 106, + 562, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 106, + 562, + 505, + 574 + ], + "score": 1.0, + "content": "Our main contribution is a differentiable neural network component that tackles this problem and", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 574, + 506, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 506, + 586 + ], + "score": 1.0, + "content": "consequently can learn to count (section 4). Used alongside an attention mechanism, this component", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 585, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 505, + 596 + ], + "score": 1.0, + "content": "avoids a fundamental limitation of soft attention while producing strong counting features. We", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 595, + 507, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 507, + 608 + ], + "score": 1.0, + "content": "provide experimental evidence of the effectiveness of this component (section 5). On a toy dataset,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 607, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 106, + 607, + 505, + 618 + ], + "score": 1.0, + "content": "we demonstrate that this component enables robust counting in a variety of scenarios. On the number", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 617, + 506, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 506, + 630 + ], + "score": 1.0, + "content": "category of the VQA v2 Open-Ended dataset (Goyal et al., 2017), a relatively simple baseline model", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 628, + 506, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 506, + 641 + ], + "score": 1.0, + "content": "using the counting component outperforms all previous models – including large ensembles of", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 639, + 423, + 652 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 423, + 652 + ], + "score": 1.0, + "content": "state-of-the-art methods – without degrading performance on other categories.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 562, + 507, + 652 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 666, + 209, + 678 + ], + "lines": [ + { + "bbox": [ + 104, + 664, + 210, + 681 + ], + "spans": [ + { + "bbox": [ + 104, + 664, + 210, + 681 + ], + "score": 1.0, + "content": "2 RELATED WORK", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 108, + 691, + 505, + 713 + ], + "lines": [ + { + "bbox": [ + 107, + 691, + 506, + 704 + ], + "spans": [ + { + "bbox": [ + 107, + 691, + 506, + 704 + ], + "score": 1.0, + "content": "Usually, greedy non-maximum suppression (NMS) is used to eliminate duplicate bounding boxes.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 107, + 702, + 505, + 714 + ], + "spans": [ + { + "bbox": [ + 107, + 702, + 505, + 714 + ], + "score": 1.0, + "content": "The main problem with using it as part of a model is that its gradient is piecewise constant. Various", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "differentiable variants such as by Azadi et al. (2017), Hosang et al. (2017), and Henderson & Ferrari", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "(2017) exist. The main difference is that, since we are interested in counting, our component does not", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "score": 1.0, + "content": "need to make discrete decisions about which bounding boxes to keep; it outputs counting features,", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 506, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 506, + 128 + ], + "score": 1.0, + "content": "not a smaller set of bounding boxes. Our component is also easily integrated into standard VQA", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 127, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 106, + 127, + 505, + 138 + ], + "score": 1.0, + "content": "models that utilize soft attention without any need for other network architecture changes and can be", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 138, + 333, + 149 + ], + "spans": [ + { + "bbox": [ + 106, + 138, + 333, + 149 + ], + "score": 1.0, + "content": "used without using true bounding boxes for supervision.", + "type": "text", + "cross_page": true + } + ], + "index": 5 + } + ], + "index": 41.5, + "bbox_fs": [ + 107, + 691, + 506, + 714 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 148 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "differentiable variants such as by Azadi et al. (2017), Hosang et al. (2017), and Henderson & Ferrari", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "(2017) exist. The main difference is that, since we are interested in counting, our component does not", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "score": 1.0, + "content": "need to make discrete decisions about which bounding boxes to keep; it outputs counting features,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 506, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 506, + 128 + ], + "score": 1.0, + "content": "not a smaller set of bounding boxes. Our component is also easily integrated into standard VQA", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 127, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 106, + 127, + 505, + 138 + ], + "score": 1.0, + "content": "models that utilize soft attention without any need for other network architecture changes and can be", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 138, + 333, + 149 + ], + "spans": [ + { + "bbox": [ + 106, + 138, + 333, + 149 + ], + "score": 1.0, + "content": "used without using true bounding boxes for supervision.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 154, + 505, + 263 + ], + "lines": [ + { + "bbox": [ + 106, + 154, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 154, + 505, + 167 + ], + "score": 1.0, + "content": "On the VQA v2 dataset (Goyal et al., 2017) that we apply our method on, only few advances on", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "score": 1.0, + "content": "counting questions have been made. The main improvement in accuracy is due to the use of object", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 176, + 506, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 506, + 189 + ], + "score": 1.0, + "content": "proposals in the visual processing pipeline, proposed by Anderson et al. (2017). Their object proposal", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "score": 1.0, + "content": "network is trained with classes in singular and plural forms, for example “tree” versus “trees”, which", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 506, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 506, + 211 + ], + "score": 1.0, + "content": "only allows primitive counting information to be present in the object features after region-of-interest", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 209, + 506, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 506, + 223 + ], + "score": 1.0, + "content": "pooling. Our approach differs in the way that instead of relying on counting features being present", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 221, + 505, + 232 + ], + "spans": [ + { + "bbox": [ + 106, + 221, + 505, + 232 + ], + "score": 1.0, + "content": "in the input, we create counting features using information present in the attention map over object", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 230, + 506, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 230, + 506, + 244 + ], + "score": 1.0, + "content": "proposals. This has the benefit of being able to count anything that the attention mechanism can", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 242, + 505, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 505, + 254 + ], + "score": 1.0, + "content": "discriminate instead of only objects that belong to the predetermined set of classes that had plural", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 252, + 136, + 265 + ], + "spans": [ + { + "bbox": [ + 105, + 252, + 136, + 265 + ], + "score": 1.0, + "content": "forms.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 107, + 270, + 505, + 336 + ], + "lines": [ + { + "bbox": [ + 106, + 269, + 506, + 282 + ], + "spans": [ + { + "bbox": [ + 106, + 269, + 506, + 282 + ], + "score": 1.0, + "content": "Using these object proposals, Trott et al. (2018) train a sequential counting mechanism with a", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 281, + 505, + 294 + ], + "spans": [ + { + "bbox": [ + 105, + 281, + 505, + 294 + ], + "score": 1.0, + "content": "reinforcement learning loss on the counting question subsets of VQA v2 and Visual Genome. They", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 292, + 505, + 304 + ], + "spans": [ + { + "bbox": [ + 106, + 292, + 505, + 304 + ], + "score": 1.0, + "content": "achieve a small increase in accuracy and can obtain an interpretable set of objects that their model", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 303, + 505, + 315 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 505, + 315 + ], + "score": 1.0, + "content": "counted, but it is unclear whether their method can be integrated into traditional VQA models due", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 313, + 506, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 506, + 326 + ], + "score": 1.0, + "content": "to their loss not applying to non-counting questions. Since they evaluate on their own dataset, their", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 325, + 356, + 337 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 356, + 337 + ], + "score": 1.0, + "content": "results can not be easily compared to existing results in VQA.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18.5 + }, + { + "type": "text", + "bbox": [ + 107, + 341, + 505, + 396 + ], + "lines": [ + { + "bbox": [ + 105, + 341, + 505, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 505, + 354 + ], + "score": 1.0, + "content": "Methods such as by Santoro et al. (2017) and Perez et al. (2017) can count on the synthetic CLEVR", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 352, + 505, + 365 + ], + "spans": [ + { + "bbox": [ + 106, + 352, + 505, + 365 + ], + "score": 1.0, + "content": "VQA dataset (Johnson et al., 2017) successfully without bounding boxes and supervision of where the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 363, + 505, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 325, + 376 + ], + "score": 1.0, + "content": "objects to count are. They also use more training data", + "type": "text" + }, + { + "bbox": [ + 325, + 363, + 367, + 374 + ], + "score": 0.54, + "content": "{ \\sim } 2 5 0 { , } 0 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 363, + 505, + 376 + ], + "score": 1.0, + "content": "counting questions in the CLEVR", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 374, + 507, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 182, + 389 + ], + "score": 1.0, + "content": "training set versus", + "type": "text" + }, + { + "bbox": [ + 182, + 375, + 219, + 385 + ], + "score": 0.86, + "content": "\\sim 5 0 { , } 0 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 374, + 507, + 389 + ], + "score": 1.0, + "content": "counting questions in the VQA v2 training set), much simpler objects,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 385, + 242, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 242, + 399 + ], + "score": 1.0, + "content": "and synthetic question structures.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 107, + 402, + 505, + 501 + ], + "lines": [ + { + "bbox": [ + 105, + 401, + 506, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 506, + 415 + ], + "score": 1.0, + "content": "More traditional approaches based on Lempitsky & Zisserman (2010) learn to produce a target", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 412, + 507, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 507, + 426 + ], + "score": 1.0, + "content": "density map, from which a count is computed by integrating over it. In this setting, Cohen et al.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 423, + 507, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 507, + 437 + ], + "score": 1.0, + "content": "(2017) make use of overlaps of convolutional receptive fields to improve counting performance.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 434, + 506, + 449 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 506, + 449 + ], + "score": 1.0, + "content": "Chattopadhyay et al. (2017) use an approach that divides the image into smaller non-overlapping", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 446, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 446, + 506, + 459 + ], + "score": 1.0, + "content": "chunks, each of which is counted individually and combined together at the end. In both of these", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 457, + 506, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 506, + 470 + ], + "score": 1.0, + "content": "contexts, the convolutional receptive fields or chunks can be seen as sets of bounding boxes with a", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 469, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 106, + 469, + 505, + 480 + ], + "score": 1.0, + "content": "fixed structure in their positioning. Note that while Chattopadhyay et al. (2017) evaluate their models", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 479, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 505, + 492 + ], + "score": 1.0, + "content": "on a small subset of counting questions in VQA, major differences in training setup make their results", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 491, + 222, + 502 + ], + "spans": [ + { + "bbox": [ + 106, + 491, + 222, + 502 + ], + "score": 1.0, + "content": "not comparable to our work.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 31 + }, + { + "type": "title", + "bbox": [ + 108, + 532, + 302, + 545 + ], + "lines": [ + { + "bbox": [ + 105, + 531, + 305, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 305, + 546 + ], + "score": 1.0, + "content": "3 PROBLEMS WITH SOFT ATTENTION", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 36 + }, + { + "type": "text", + "bbox": [ + 107, + 565, + 504, + 599 + ], + "lines": [ + { + "bbox": [ + 106, + 566, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 566, + 505, + 578 + ], + "score": 1.0, + "content": "The main message in this section is that using the feature vectors obtained after the attention", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 577, + 506, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 589 + ], + "score": 1.0, + "content": "mechanism is not enough to be able to count; the attention maps themselves should be used, which is", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 587, + 267, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 267, + 601 + ], + "score": 1.0, + "content": "what we do in our counting component.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 107, + 604, + 504, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "score": 1.0, + "content": "Models in VQA have consistently benefited from the use of soft attention (Mnih et al., 2014; Bahdanau", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 615, + 506, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 506, + 629 + ], + "score": 1.0, + "content": "et al., 2015) on the image, commonly implemented with a shallow convolutional network. It learns", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 627, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 506, + 640 + ], + "score": 1.0, + "content": "to output a weight for the feature vector at each spatial position in the feature map, which is first", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "score": 1.0, + "content": "normalized and then used for performing a weighted sum over the spatial positions to produce a", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 649, + 506, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 506, + 662 + ], + "score": 1.0, + "content": "single feature vector. However, soft spatial attention severely limits the ability for a model to count.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "Consider the task of counting the number of cats for two images: an image showing a single cat on a", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "score": 1.0, + "content": "clean background and an image that consists of two side-by-side copies of the first image. What we", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "will describe applies to both spatial feature maps and sets of object proposals as input, but we focus", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "on the latter case for simplicity. With an object detection network, we detect one cat in the first image", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "and two cats in the second image, producing the same feature vector for all three detections. The", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 720, + 448, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 448, + 732 + ], + "score": 1.0, + "content": "attention mechanism then assigns all three instances of the same cat the same weight.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 47.5 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "score": 1.0, + "content": "2", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 148 + ], + "lines": [], + "index": 2.5, + "bbox_fs": [ + 105, + 82, + 506, + 149 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 154, + 505, + 263 + ], + "lines": [ + { + "bbox": [ + 106, + 154, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 154, + 505, + 167 + ], + "score": 1.0, + "content": "On the VQA v2 dataset (Goyal et al., 2017) that we apply our method on, only few advances on", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "score": 1.0, + "content": "counting questions have been made. The main improvement in accuracy is due to the use of object", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 176, + 506, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 506, + 189 + ], + "score": 1.0, + "content": "proposals in the visual processing pipeline, proposed by Anderson et al. (2017). Their object proposal", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "score": 1.0, + "content": "network is trained with classes in singular and plural forms, for example “tree” versus “trees”, which", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 506, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 506, + 211 + ], + "score": 1.0, + "content": "only allows primitive counting information to be present in the object features after region-of-interest", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 209, + 506, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 506, + 223 + ], + "score": 1.0, + "content": "pooling. Our approach differs in the way that instead of relying on counting features being present", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 221, + 505, + 232 + ], + "spans": [ + { + "bbox": [ + 106, + 221, + 505, + 232 + ], + "score": 1.0, + "content": "in the input, we create counting features using information present in the attention map over object", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 230, + 506, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 230, + 506, + 244 + ], + "score": 1.0, + "content": "proposals. This has the benefit of being able to count anything that the attention mechanism can", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 242, + 505, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 505, + 254 + ], + "score": 1.0, + "content": "discriminate instead of only objects that belong to the predetermined set of classes that had plural", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 252, + 136, + 265 + ], + "spans": [ + { + "bbox": [ + 105, + 252, + 136, + 265 + ], + "score": 1.0, + "content": "forms.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 154, + 506, + 265 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 270, + 505, + 336 + ], + "lines": [ + { + "bbox": [ + 106, + 269, + 506, + 282 + ], + "spans": [ + { + "bbox": [ + 106, + 269, + 506, + 282 + ], + "score": 1.0, + "content": "Using these object proposals, Trott et al. (2018) train a sequential counting mechanism with a", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 281, + 505, + 294 + ], + "spans": [ + { + "bbox": [ + 105, + 281, + 505, + 294 + ], + "score": 1.0, + "content": "reinforcement learning loss on the counting question subsets of VQA v2 and Visual Genome. They", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 292, + 505, + 304 + ], + "spans": [ + { + "bbox": [ + 106, + 292, + 505, + 304 + ], + "score": 1.0, + "content": "achieve a small increase in accuracy and can obtain an interpretable set of objects that their model", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 303, + 505, + 315 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 505, + 315 + ], + "score": 1.0, + "content": "counted, but it is unclear whether their method can be integrated into traditional VQA models due", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 313, + 506, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 506, + 326 + ], + "score": 1.0, + "content": "to their loss not applying to non-counting questions. Since they evaluate on their own dataset, their", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 325, + 356, + 337 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 356, + 337 + ], + "score": 1.0, + "content": "results can not be easily compared to existing results in VQA.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18.5, + "bbox_fs": [ + 105, + 269, + 506, + 337 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 341, + 505, + 396 + ], + "lines": [ + { + "bbox": [ + 105, + 341, + 505, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 505, + 354 + ], + "score": 1.0, + "content": "Methods such as by Santoro et al. (2017) and Perez et al. (2017) can count on the synthetic CLEVR", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 352, + 505, + 365 + ], + "spans": [ + { + "bbox": [ + 106, + 352, + 505, + 365 + ], + "score": 1.0, + "content": "VQA dataset (Johnson et al., 2017) successfully without bounding boxes and supervision of where the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 363, + 505, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 325, + 376 + ], + "score": 1.0, + "content": "objects to count are. They also use more training data", + "type": "text" + }, + { + "bbox": [ + 325, + 363, + 367, + 374 + ], + "score": 0.54, + "content": "{ \\sim } 2 5 0 { , } 0 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 363, + 505, + 376 + ], + "score": 1.0, + "content": "counting questions in the CLEVR", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 374, + 507, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 182, + 389 + ], + "score": 1.0, + "content": "training set versus", + "type": "text" + }, + { + "bbox": [ + 182, + 375, + 219, + 385 + ], + "score": 0.86, + "content": "\\sim 5 0 { , } 0 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 374, + 507, + 389 + ], + "score": 1.0, + "content": "counting questions in the VQA v2 training set), much simpler objects,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 385, + 242, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 242, + 399 + ], + "score": 1.0, + "content": "and synthetic question structures.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 24, + "bbox_fs": [ + 105, + 341, + 507, + 399 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 402, + 505, + 501 + ], + "lines": [ + { + "bbox": [ + 105, + 401, + 506, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 506, + 415 + ], + "score": 1.0, + "content": "More traditional approaches based on Lempitsky & Zisserman (2010) learn to produce a target", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 412, + 507, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 507, + 426 + ], + "score": 1.0, + "content": "density map, from which a count is computed by integrating over it. In this setting, Cohen et al.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 423, + 507, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 507, + 437 + ], + "score": 1.0, + "content": "(2017) make use of overlaps of convolutional receptive fields to improve counting performance.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 434, + 506, + 449 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 506, + 449 + ], + "score": 1.0, + "content": "Chattopadhyay et al. (2017) use an approach that divides the image into smaller non-overlapping", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 446, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 446, + 506, + 459 + ], + "score": 1.0, + "content": "chunks, each of which is counted individually and combined together at the end. In both of these", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 457, + 506, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 506, + 470 + ], + "score": 1.0, + "content": "contexts, the convolutional receptive fields or chunks can be seen as sets of bounding boxes with a", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 469, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 106, + 469, + 505, + 480 + ], + "score": 1.0, + "content": "fixed structure in their positioning. Note that while Chattopadhyay et al. (2017) evaluate their models", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 479, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 505, + 492 + ], + "score": 1.0, + "content": "on a small subset of counting questions in VQA, major differences in training setup make their results", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 491, + 222, + 502 + ], + "spans": [ + { + "bbox": [ + 106, + 491, + 222, + 502 + ], + "score": 1.0, + "content": "not comparable to our work.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 31, + "bbox_fs": [ + 105, + 401, + 507, + 502 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 532, + 302, + 545 + ], + "lines": [ + { + "bbox": [ + 105, + 531, + 305, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 305, + 546 + ], + "score": 1.0, + "content": "3 PROBLEMS WITH SOFT ATTENTION", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 36 + }, + { + "type": "text", + "bbox": [ + 107, + 565, + 504, + 599 + ], + "lines": [ + { + "bbox": [ + 106, + 566, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 566, + 505, + 578 + ], + "score": 1.0, + "content": "The main message in this section is that using the feature vectors obtained after the attention", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 577, + 506, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 589 + ], + "score": 1.0, + "content": "mechanism is not enough to be able to count; the attention maps themselves should be used, which is", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 587, + 267, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 267, + 601 + ], + "score": 1.0, + "content": "what we do in our counting component.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 566, + 506, + 601 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 604, + 504, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "score": 1.0, + "content": "Models in VQA have consistently benefited from the use of soft attention (Mnih et al., 2014; Bahdanau", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 615, + 506, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 506, + 629 + ], + "score": 1.0, + "content": "et al., 2015) on the image, commonly implemented with a shallow convolutional network. It learns", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 627, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 506, + 640 + ], + "score": 1.0, + "content": "to output a weight for the feature vector at each spatial position in the feature map, which is first", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "score": 1.0, + "content": "normalized and then used for performing a weighted sum over the spatial positions to produce a", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 649, + 506, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 506, + 662 + ], + "score": 1.0, + "content": "single feature vector. However, soft spatial attention severely limits the ability for a model to count.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 42, + "bbox_fs": [ + 105, + 604, + 506, + 662 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "Consider the task of counting the number of cats for two images: an image showing a single cat on a", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "score": 1.0, + "content": "clean background and an image that consists of two side-by-side copies of the first image. What we", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "will describe applies to both spatial feature maps and sets of object proposals as input, but we focus", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "on the latter case for simplicity. With an object detection network, we detect one cat in the first image", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "and two cats in the second image, producing the same feature vector for all three detections. The", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 720, + 448, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 448, + 732 + ], + "score": 1.0, + "content": "attention mechanism then assigns all three instances of the same cat the same weight.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 47.5, + "bbox_fs": [ + 105, + 665, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 113, + 79, + 497, + 142 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 113, + 79, + 497, + 142 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 113, + 79, + 497, + 142 + ], + "spans": [ + { + "bbox": [ + 113, + 79, + 497, + 142 + ], + "score": 0.965, + "type": "image", + "image_path": "01c2c43239e5530d6490c14c6c93b92ad5fef0ff207f0d931d1ff4b6596146b9.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 113, + 79, + 497, + 100.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 113, + 100.0, + 497, + 121.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 113, + 121.0, + 497, + 142.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 154, + 506, + 243 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 155, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 155, + 505, + 167 + ], + "score": 1.0, + "content": "Figure 1: Simplified example about counting the number of cats. The light-colored cat is detected", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 167, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 106, + 167, + 505, + 177 + ], + "score": 1.0, + "content": "twice and results in a duplicate proposal. This shows the conversion from the attention weights a", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 176, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 505, + 189 + ], + "score": 1.0, + "content": "to a graph representation A and the eventual goal of this component with exactly one proposal per", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 188, + 506, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 506, + 200 + ], + "score": 1.0, + "content": "true object. There are 4 proposals (vertices) capturing 3 underlying objects (groups in dotted lines).", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 198, + 506, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 506, + 211 + ], + "score": 1.0, + "content": "There are 3 relevant proposals (black with weight 1) and 1 irrelevant proposal (white with weight", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 209, + 506, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 506, + 223 + ], + "score": 1.0, + "content": "0). Red edges mark intra-object edges between duplicate proposals and blue edges mark the main", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 220, + 506, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 506, + 234 + ], + "score": 1.0, + "content": "inter-object duplicate edges. In graph form, the object groups, coloring of edges, and shading of", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 231, + 488, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 488, + 245 + ], + "score": 1.0, + "content": "vertices serve illustration purposes only; the model does not have these access to these directly.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6.5 + } + ], + "index": 3.75 + }, + { + "type": "text", + "bbox": [ + 107, + 270, + 505, + 347 + ], + "lines": [ + { + "bbox": [ + 105, + 270, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 505, + 282 + ], + "score": 1.0, + "content": "The usual normalization used for the attention weights is the softmax function, which normalizes the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 281, + 505, + 294 + ], + "spans": [ + { + "bbox": [ + 106, + 281, + 505, + 294 + ], + "score": 1.0, + "content": "weights to sum to 1. Herein lies the problem: the cat in the first image receives a normalized weight", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 291, + 507, + 305 + ], + "spans": [ + { + "bbox": [ + 105, + 291, + 507, + 305 + ], + "score": 1.0, + "content": "of 1, but the two cats in the second image now each receive a weight of 0.5. After the weighted sum,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 303, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 303, + 506, + 316 + ], + "score": 1.0, + "content": "we are effectively averaging the two cats in the second image back to a single cat. As a consequence,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 315, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 106, + 315, + 505, + 326 + ], + "score": 1.0, + "content": "the feature vector obtained after the weighted sum is exactly the same between the two images and we", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 325, + 505, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 505, + 338 + ], + "score": 1.0, + "content": "have lost all information about a possible count from the attention map. Any method that normalizes", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 337, + 295, + 348 + ], + "spans": [ + { + "bbox": [ + 106, + 337, + 295, + 348 + ], + "score": 1.0, + "content": "the weights to sum to 1 suffers from this issue.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 352, + 505, + 441 + ], + "lines": [ + { + "bbox": [ + 106, + 353, + 506, + 364 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 506, + 364 + ], + "score": 1.0, + "content": "Multiple glimpses (Larochelle & Hinton, 2010) – sets of attention weights that the attention mecha-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 364, + 505, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 364, + 505, + 376 + ], + "score": 1.0, + "content": "nism outputs – or several steps of attention (Yang et al., 2016; Lu et al., 2016) do not circumvent this", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 376, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 505, + 387 + ], + "score": 1.0, + "content": "problem. Each glimpse or step can not separate out an object each, since the attention weight given to", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 387, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 106, + 387, + 505, + 398 + ], + "score": 1.0, + "content": "one feature vector does not depend on the other feature vectors to be attended over. Hard attention (Ba", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 397, + 505, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 505, + 409 + ], + "score": 1.0, + "content": "et al., 2015; Mnih et al., 2014) and structured attention (Kim et al., 2017) may be possible solutions", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 408, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 505, + 420 + ], + "score": 1.0, + "content": "to this, though no significant improvement in counting ability has been found for the latter so far (Zhu", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 419, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 505, + 431 + ], + "score": 1.0, + "content": "et al., 2017). Ren & Zemel (2017) circumvent the problem by limiting attention to only work within", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 430, + 488, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 488, + 442 + ], + "score": 1.0, + "content": "one bounding box at a time, remotely similar to our approach of using object proposal features.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 21.5 + }, + { + "type": "text", + "bbox": [ + 107, + 446, + 505, + 535 + ], + "lines": [ + { + "bbox": [ + 105, + 445, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 505, + 459 + ], + "score": 1.0, + "content": "Without normalization of weights to sum to one, the scale of the output features depends on the", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 457, + 506, + 470 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 506, + 470 + ], + "score": 1.0, + "content": "number of objects detected. In an image with 10 cats, the output feature vector is scaled up by 10.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 468, + 506, + 482 + ], + "spans": [ + { + "bbox": [ + 106, + 468, + 506, + 482 + ], + "score": 1.0, + "content": "Since deep neural networks are typically very scale-sensitive – the scale of weight initializations", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 479, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 505, + 492 + ], + "score": 1.0, + "content": "and activations is generally considered quite important (Mishkin & Matas, 2016) – and the classifier", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 490, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 106, + 490, + 505, + 502 + ], + "score": 1.0, + "content": "would have to learn that joint scaling of all features is somehow related to count, this approach is not", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "score": 1.0, + "content": "reasonable for counting objects. This is evidenced in Teney et al. (2017) where they provide evidence", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 512, + 506, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 506, + 525 + ], + "score": 1.0, + "content": "that sigmoid normalization not only degrades accuracy on non-number questions slightly, but also", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 523, + 222, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 222, + 536 + ], + "score": 1.0, + "content": "does not help with counting.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 29.5 + }, + { + "type": "title", + "bbox": [ + 108, + 559, + 250, + 571 + ], + "lines": [ + { + "bbox": [ + 105, + 558, + 252, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 252, + 573 + ], + "score": 1.0, + "content": "4 COUNTING COMPONENT", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 587, + 505, + 643 + ], + "lines": [ + { + "bbox": [ + 106, + 588, + 505, + 600 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 505, + 600 + ], + "score": 1.0, + "content": "In this section, we describe a differentiable mechanism for counting from attention weights, while", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 598, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 506, + 613 + ], + "score": 1.0, + "content": "also dealing with the problem of overlapping object proposals to reduce double-counting of objects.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "score": 1.0, + "content": "This involves some nontrivial details to produce counts that are as accurate as possible. The main", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 621, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 621, + 505, + 633 + ], + "score": 1.0, + "content": "idea is illustrated in Figure 1 with the two main steps shown in Figure 2 and Figure 3. The use of this", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 632, + 493, + 645 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 493, + 645 + ], + "score": 1.0, + "content": "component allows a model to count while still being able to exploit the benefits of soft attention.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 649, + 505, + 682 + ], + "lines": [ + { + "bbox": [ + 105, + 648, + 506, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 506, + 662 + ], + "score": 1.0, + "content": "Our key idea for dealing with overlapping object proposals is to turn these object proposals into a", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 660, + 506, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 506, + 673 + ], + "score": 1.0, + "content": "graph that is based on how they overlap. We then remove and scale edges in a specific way such that", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 671, + 352, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 352, + 683 + ], + "score": 1.0, + "content": "an estimate of the number of underlying objects is recovered.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 108, + 687, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "Our general strategy is to primarily design the component for the unrealistic extreme cases of perfect", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 697, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 505, + 712 + ], + "score": 1.0, + "content": "attention maps and bounding boxes that are either fully overlapping or fully distinct. By introducing", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 710, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 506, + 723 + ], + "score": 1.0, + "content": "some parameters and only using differentiable operations, we give the ability for the module to", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 721, + 507, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 507, + 733 + ], + "score": 1.0, + "content": "interpolate between the correct behaviours for these extreme cases to handle the more realistic cases.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 44.5 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 303, + 751, + 309, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 113, + 79, + 497, + 142 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 113, + 79, + 497, + 142 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 113, + 79, + 497, + 142 + ], + "spans": [ + { + "bbox": [ + 113, + 79, + 497, + 142 + ], + "score": 0.965, + "type": "image", + "image_path": "01c2c43239e5530d6490c14c6c93b92ad5fef0ff207f0d931d1ff4b6596146b9.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 113, + 79, + 497, + 100.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 113, + 100.0, + 497, + 121.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 113, + 121.0, + 497, + 142.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 154, + 506, + 243 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 155, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 155, + 505, + 167 + ], + "score": 1.0, + "content": "Figure 1: Simplified example about counting the number of cats. The light-colored cat is detected", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 167, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 106, + 167, + 505, + 177 + ], + "score": 1.0, + "content": "twice and results in a duplicate proposal. This shows the conversion from the attention weights a", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 176, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 505, + 189 + ], + "score": 1.0, + "content": "to a graph representation A and the eventual goal of this component with exactly one proposal per", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 188, + 506, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 506, + 200 + ], + "score": 1.0, + "content": "true object. There are 4 proposals (vertices) capturing 3 underlying objects (groups in dotted lines).", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 198, + 506, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 506, + 211 + ], + "score": 1.0, + "content": "There are 3 relevant proposals (black with weight 1) and 1 irrelevant proposal (white with weight", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 209, + 506, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 506, + 223 + ], + "score": 1.0, + "content": "0). Red edges mark intra-object edges between duplicate proposals and blue edges mark the main", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 220, + 506, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 506, + 234 + ], + "score": 1.0, + "content": "inter-object duplicate edges. In graph form, the object groups, coloring of edges, and shading of", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 231, + 488, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 488, + 245 + ], + "score": 1.0, + "content": "vertices serve illustration purposes only; the model does not have these access to these directly.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6.5 + } + ], + "index": 3.75 + }, + { + "type": "text", + "bbox": [ + 107, + 270, + 505, + 347 + ], + "lines": [ + { + "bbox": [ + 105, + 270, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 505, + 282 + ], + "score": 1.0, + "content": "The usual normalization used for the attention weights is the softmax function, which normalizes the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 281, + 505, + 294 + ], + "spans": [ + { + "bbox": [ + 106, + 281, + 505, + 294 + ], + "score": 1.0, + "content": "weights to sum to 1. Herein lies the problem: the cat in the first image receives a normalized weight", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 291, + 507, + 305 + ], + "spans": [ + { + "bbox": [ + 105, + 291, + 507, + 305 + ], + "score": 1.0, + "content": "of 1, but the two cats in the second image now each receive a weight of 0.5. After the weighted sum,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 303, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 303, + 506, + 316 + ], + "score": 1.0, + "content": "we are effectively averaging the two cats in the second image back to a single cat. As a consequence,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 315, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 106, + 315, + 505, + 326 + ], + "score": 1.0, + "content": "the feature vector obtained after the weighted sum is exactly the same between the two images and we", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 325, + 505, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 505, + 338 + ], + "score": 1.0, + "content": "have lost all information about a possible count from the attention map. Any method that normalizes", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 337, + 295, + 348 + ], + "spans": [ + { + "bbox": [ + 106, + 337, + 295, + 348 + ], + "score": 1.0, + "content": "the weights to sum to 1 suffers from this issue.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14, + "bbox_fs": [ + 105, + 270, + 507, + 348 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 352, + 505, + 441 + ], + "lines": [ + { + "bbox": [ + 106, + 353, + 506, + 364 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 506, + 364 + ], + "score": 1.0, + "content": "Multiple glimpses (Larochelle & Hinton, 2010) – sets of attention weights that the attention mecha-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 364, + 505, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 364, + 505, + 376 + ], + "score": 1.0, + "content": "nism outputs – or several steps of attention (Yang et al., 2016; Lu et al., 2016) do not circumvent this", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 376, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 505, + 387 + ], + "score": 1.0, + "content": "problem. Each glimpse or step can not separate out an object each, since the attention weight given to", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 387, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 106, + 387, + 505, + 398 + ], + "score": 1.0, + "content": "one feature vector does not depend on the other feature vectors to be attended over. Hard attention (Ba", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 397, + 505, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 505, + 409 + ], + "score": 1.0, + "content": "et al., 2015; Mnih et al., 2014) and structured attention (Kim et al., 2017) may be possible solutions", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 408, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 505, + 420 + ], + "score": 1.0, + "content": "to this, though no significant improvement in counting ability has been found for the latter so far (Zhu", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 419, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 505, + 431 + ], + "score": 1.0, + "content": "et al., 2017). Ren & Zemel (2017) circumvent the problem by limiting attention to only work within", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 430, + 488, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 488, + 442 + ], + "score": 1.0, + "content": "one bounding box at a time, remotely similar to our approach of using object proposal features.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 353, + 506, + 442 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 446, + 505, + 535 + ], + "lines": [ + { + "bbox": [ + 105, + 445, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 505, + 459 + ], + "score": 1.0, + "content": "Without normalization of weights to sum to one, the scale of the output features depends on the", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 457, + 506, + 470 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 506, + 470 + ], + "score": 1.0, + "content": "number of objects detected. In an image with 10 cats, the output feature vector is scaled up by 10.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 468, + 506, + 482 + ], + "spans": [ + { + "bbox": [ + 106, + 468, + 506, + 482 + ], + "score": 1.0, + "content": "Since deep neural networks are typically very scale-sensitive – the scale of weight initializations", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 479, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 505, + 492 + ], + "score": 1.0, + "content": "and activations is generally considered quite important (Mishkin & Matas, 2016) – and the classifier", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 490, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 106, + 490, + 505, + 502 + ], + "score": 1.0, + "content": "would have to learn that joint scaling of all features is somehow related to count, this approach is not", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "score": 1.0, + "content": "reasonable for counting objects. This is evidenced in Teney et al. (2017) where they provide evidence", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 512, + 506, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 506, + 525 + ], + "score": 1.0, + "content": "that sigmoid normalization not only degrades accuracy on non-number questions slightly, but also", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 523, + 222, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 222, + 536 + ], + "score": 1.0, + "content": "does not help with counting.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 29.5, + "bbox_fs": [ + 105, + 445, + 506, + 536 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 559, + 250, + 571 + ], + "lines": [ + { + "bbox": [ + 105, + 558, + 252, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 252, + 573 + ], + "score": 1.0, + "content": "4 COUNTING COMPONENT", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 587, + 505, + 643 + ], + "lines": [ + { + "bbox": [ + 106, + 588, + 505, + 600 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 505, + 600 + ], + "score": 1.0, + "content": "In this section, we describe a differentiable mechanism for counting from attention weights, while", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 598, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 506, + 613 + ], + "score": 1.0, + "content": "also dealing with the problem of overlapping object proposals to reduce double-counting of objects.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "score": 1.0, + "content": "This involves some nontrivial details to produce counts that are as accurate as possible. The main", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 621, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 621, + 505, + 633 + ], + "score": 1.0, + "content": "idea is illustrated in Figure 1 with the two main steps shown in Figure 2 and Figure 3. The use of this", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 632, + 493, + 645 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 493, + 645 + ], + "score": 1.0, + "content": "component allows a model to count while still being able to exploit the benefits of soft attention.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 37, + "bbox_fs": [ + 105, + 588, + 506, + 645 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 649, + 505, + 682 + ], + "lines": [ + { + "bbox": [ + 105, + 648, + 506, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 506, + 662 + ], + "score": 1.0, + "content": "Our key idea for dealing with overlapping object proposals is to turn these object proposals into a", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 660, + 506, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 506, + 673 + ], + "score": 1.0, + "content": "graph that is based on how they overlap. We then remove and scale edges in a specific way such that", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 671, + 352, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 352, + 683 + ], + "score": 1.0, + "content": "an estimate of the number of underlying objects is recovered.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41, + "bbox_fs": [ + 105, + 648, + 506, + 683 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 687, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "Our general strategy is to primarily design the component for the unrealistic extreme cases of perfect", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 697, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 505, + 712 + ], + "score": 1.0, + "content": "attention maps and bounding boxes that are either fully overlapping or fully distinct. By introducing", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 710, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 506, + 723 + ], + "score": 1.0, + "content": "some parameters and only using differentiable operations, we give the ability for the module to", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 721, + 507, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 507, + 733 + ], + "score": 1.0, + "content": "interpolate between the correct behaviours for these extreme cases to handle the more realistic cases.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 44.5, + "bbox_fs": [ + 105, + 687, + 507, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 506, + 96 + ], + "score": 1.0, + "content": "These parameters are responsible for handling variations in attention weights and partial bounding", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 321, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 321, + 106 + ], + "score": 1.0, + "content": "box overlaps in a manner suitable for a given dataset.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 107, + 110, + 505, + 209 + ], + "lines": [ + { + "bbox": [ + 105, + 109, + 505, + 123 + ], + "spans": [ + { + "bbox": [ + 105, + 109, + 336, + 123 + ], + "score": 1.0, + "content": "To achieve this, we use several piecewise linear functions", + "type": "text" + }, + { + "bbox": [ + 336, + 111, + 378, + 122 + ], + "score": 0.93, + "content": "f _ { 1 } , \\ldots , f _ { 8 }", + "type": "inline_equation" + }, + { + "bbox": [ + 378, + 109, + 505, + 123 + ], + "score": 1.0, + "content": "as activation functions (defined", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 121, + 505, + 134 + ], + "spans": [ + { + "bbox": [ + 106, + 121, + 505, + 134 + ], + "score": 1.0, + "content": "in Appendix A), approximating arbitrary functions with domain and range [0, 1]. The shapes of", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 132, + 505, + 145 + ], + "spans": [ + { + "bbox": [ + 106, + 132, + 505, + 145 + ], + "score": 1.0, + "content": "these functions are learned to handle the specific nonlinear interactions necessary for dealing with", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 143, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 106, + 143, + 394, + 156 + ], + "score": 1.0, + "content": "overlapping proposals. Through their parametrization we enforce that", + "type": "text" + }, + { + "bbox": [ + 394, + 143, + 437, + 155 + ], + "score": 0.89, + "content": "f _ { k } ( 0 ) = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 143, + 441, + 156 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 441, + 143, + 484, + 155 + ], + "score": 0.89, + "content": "f _ { k } ( 1 ) = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 143, + 505, + 156 + ], + "score": 1.0, + "content": ", and", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 153, + 506, + 168 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 506, + 168 + ], + "score": 1.0, + "content": "that they are monotonically increasing. The first two properties are required so that the extreme cases", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 163, + 506, + 180 + ], + "spans": [ + { + "bbox": [ + 105, + 163, + 344, + 180 + ], + "score": 1.0, + "content": "that we explicitly handle are left unchanged. In those cases,", + "type": "text" + }, + { + "bbox": [ + 344, + 165, + 356, + 177 + ], + "score": 0.88, + "content": "f _ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 163, + 506, + 180 + ], + "score": 1.0, + "content": "is only applied to values of 0 or 1, so", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 177, + 506, + 189 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 506, + 189 + ], + "score": 1.0, + "content": "the activation functions can be safely ignored for understanding how the component handles them.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 188, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 106, + 188, + 505, + 200 + ], + "score": 1.0, + "content": "By enforcing monotonicity, we can make sure that, for example, an increased value in an attention", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 199, + 371, + 210 + ], + "spans": [ + { + "bbox": [ + 106, + 199, + 371, + 210 + ], + "score": 1.0, + "content": "map should never result in the prediction of the count to decrease.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6 + }, + { + "type": "title", + "bbox": [ + 107, + 222, + 158, + 234 + ], + "lines": [ + { + "bbox": [ + 105, + 221, + 160, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 160, + 236 + ], + "score": 1.0, + "content": "4.1 INPUT", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 107, + 243, + 505, + 287 + ], + "lines": [ + { + "bbox": [ + 105, + 242, + 505, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 505, + 255 + ], + "score": 1.0, + "content": "Given a set of features from object proposals, an attention mechanism produces a weight for each", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 254, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 399, + 266 + ], + "score": 1.0, + "content": "proposal based on the question. The counting component takes as input the", + "type": "text" + }, + { + "bbox": [ + 400, + 256, + 407, + 263 + ], + "score": 0.71, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 254, + 505, + 266 + ], + "score": 1.0, + "content": "largest attention weights", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 107, + 264, + 505, + 279 + ], + "spans": [ + { + "bbox": [ + 107, + 264, + 180, + 277 + ], + "score": 0.92, + "content": "\\mathbf { \\bar { a } } = [ a _ { 1 } , \\ldots , a _ { n } ] ^ { \\mathsf { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 264, + 347, + 279 + ], + "score": 1.0, + "content": "and their corresponding bounding boxes", + "type": "text" + }, + { + "bbox": [ + 347, + 265, + 419, + 277 + ], + "score": 0.9, + "content": "\\mathbf { b } = [ b _ { 1 } , \\ldots , b _ { n } ] ^ { \\mathsf { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 264, + 505, + 279 + ], + "score": 1.0, + "content": ". We assume that the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 276, + 479, + 288 + ], + "spans": [ + { + "bbox": [ + 106, + 276, + 210, + 288 + ], + "score": 1.0, + "content": "weights lie in the interval", + "type": "text" + }, + { + "bbox": [ + 210, + 276, + 231, + 288 + ], + "score": 0.56, + "content": "[ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 276, + 479, + 288 + ], + "score": 1.0, + "content": ", which can easily be achieved by applying a logistic function.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 107, + 292, + 505, + 381 + ], + "lines": [ + { + "bbox": [ + 105, + 293, + 506, + 305 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 506, + 305 + ], + "score": 1.0, + "content": "In the extreme cases that we explicitly handle, we assume that the attention mechanism assigns a", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 304, + 506, + 315 + ], + "spans": [ + { + "bbox": [ + 106, + 304, + 160, + 315 + ], + "score": 1.0, + "content": "value of 1 to", + "type": "text" + }, + { + "bbox": [ + 160, + 305, + 170, + 315 + ], + "score": 0.83, + "content": "a _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 304, + 506, + 315 + ], + "score": 1.0, + "content": "whenever the ith proposal contains a relevant object and a value of 0 whenever it", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 315, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 506, + 327 + ], + "score": 1.0, + "content": "does not. This is in line with what usual soft attention mechanisms learn, as they produce higher", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 326, + 505, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 505, + 338 + ], + "score": 1.0, + "content": "weights for relevant inputs. We also assume that either two object proposals fully overlap (in which", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 336, + 505, + 349 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 505, + 349 + ], + "score": 1.0, + "content": "case they must be showing the same object and thus receive the same attention weight) or that they", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 348, + 505, + 360 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 505, + 360 + ], + "score": 1.0, + "content": "are fully distinct (in which case they show different objects). Keep in mind that while we make these", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 359, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 505, + 371 + ], + "score": 1.0, + "content": "assumptions to make reasoning about the behaviour easier, the learned parameters in the activation", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 368, + 493, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 368, + 493, + 383 + ], + "score": 1.0, + "content": "functions are intended to handle the more realistic scenarios when the assumptions do not apply.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 107, + 386, + 504, + 409 + ], + "lines": [ + { + "bbox": [ + 105, + 385, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 505, + 400 + ], + "score": 1.0, + "content": "Instead of partially overlapping proposals, the problem now becomes the handling of exact duplicate", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 397, + 343, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 343, + 410 + ], + "score": 1.0, + "content": "proposals of underlying objects in a differentiable manner.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5 + }, + { + "type": "title", + "bbox": [ + 107, + 422, + 203, + 433 + ], + "lines": [ + { + "bbox": [ + 106, + 421, + 204, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 204, + 434 + ], + "score": 1.0, + "content": "4.2 DEDUPLICATION", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 442, + 504, + 476 + ], + "lines": [ + { + "bbox": [ + 105, + 441, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 506, + 455 + ], + "score": 1.0, + "content": "We start by changing the vector of attention weights a into a graph representation in which bounding", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "score": 1.0, + "content": "boxes can be utilized more easily. Hence, we compute the outer product of the attention weights to", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 465, + 214, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 465, + 214, + 475 + ], + "score": 1.0, + "content": "obtain an attention matrix.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28 + }, + { + "type": "interline_equation", + "bbox": [ + 285, + 490, + 326, + 504 + ], + "lines": [ + { + "bbox": [ + 285, + 490, + 326, + 504 + ], + "spans": [ + { + "bbox": [ + 285, + 490, + 326, + 504 + ], + "score": 0.89, + "content": "\\mathbf { A } = \\mathbf { a } \\mathbf { a } ^ { \\mathsf { T } }", + "type": "interline_equation", + "image_path": "45d21d32766cf3e79ac4874ade1c995e6282fbe88bba109fb973d8aace126ef1.jpg" + } + ] + } + ], + "index": 30, + "virtual_lines": [ + { + "bbox": [ + 285, + 490, + 326, + 504 + ], + "spans": [], + "index": 30 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 511, + 504, + 566 + ], + "lines": [ + { + "bbox": [ + 106, + 509, + 506, + 525 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 152, + 522 + ], + "score": 0.9, + "content": "\\mathbf { A } \\in \\mathbb { R } ^ { n \\times n }", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 509, + 506, + 525 + ], + "score": 1.0, + "content": "can be interpreted as an adjacency matrix for a weighted directed graph. In this graph, the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 522, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 329, + 534 + ], + "score": 1.0, + "content": "ith vertex represents the object proposal associated with", + "type": "text" + }, + { + "bbox": [ + 329, + 524, + 339, + 533 + ], + "score": 0.85, + "content": "a _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 522, + 505, + 534 + ], + "score": 1.0, + "content": "and the edge between any pair of vertices", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 533, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 106, + 533, + 127, + 545 + ], + "score": 0.93, + "content": "( i , j )", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 533, + 175, + 546 + ], + "score": 1.0, + "content": "has weight", + "type": "text" + }, + { + "bbox": [ + 175, + 534, + 194, + 545 + ], + "score": 0.89, + "content": "a _ { i } a _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 195, + 533, + 309, + 546 + ], + "score": 1.0, + "content": ". In the extreme case where", + "type": "text" + }, + { + "bbox": [ + 309, + 534, + 319, + 544 + ], + "score": 0.86, + "content": "a _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 533, + 506, + 546 + ], + "score": 1.0, + "content": "is virtually 0 or 1, products are equivalent to", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 544, + 506, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 466, + 557 + ], + "score": 1.0, + "content": "logical AND operators. It follows that the subgraph containing only the vertices satisfying", + "type": "text" + }, + { + "bbox": [ + 467, + 545, + 495, + 555 + ], + "score": 0.91, + "content": "a _ { i } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 544, + 506, + 557 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 554, + 250, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 250, + 568 + ], + "score": 1.0, + "content": "a complete digraph with self-loops.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 107, + 571, + 505, + 662 + ], + "lines": [ + { + "bbox": [ + 105, + 570, + 505, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 505, + 585 + ], + "score": 1.0, + "content": "In this representation, our objective is to eliminate edges in such a way that, conceptually, the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 583, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 583, + 505, + 595 + ], + "score": 1.0, + "content": "underlying true objects – instead of proposals thereof – are the vertices of that complete subgraph. In", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 399, + 606 + ], + "score": 1.0, + "content": "order to then turn that graph into a count, recall that the number of edges", + "type": "text" + }, + { + "bbox": [ + 400, + 594, + 414, + 605 + ], + "score": 0.89, + "content": "| E |", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "in a complete digraph", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 603, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 303, + 618 + ], + "score": 1.0, + "content": "with self-loops relates to the number of vertices", + "type": "text" + }, + { + "bbox": [ + 303, + 605, + 318, + 617 + ], + "score": 0.88, + "content": "| V |", + "type": "inline_equation" + }, + { + "bbox": [ + 318, + 603, + 354, + 618 + ], + "score": 1.0, + "content": "through", + "type": "text" + }, + { + "bbox": [ + 354, + 605, + 400, + 617 + ], + "score": 0.76, + "content": "| E | = | V | ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 603, + 405, + 618 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 405, + 605, + 420, + 617 + ], + "score": 0.7, + "content": "| E |", + "type": "inline_equation" + }, + { + "bbox": [ + 420, + 603, + 505, + 618 + ], + "score": 1.0, + "content": "can be computed by", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 615, + 504, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 325, + 629 + ], + "score": 1.0, + "content": "summing over the entries in an adjacency matrix and", + "type": "text" + }, + { + "bbox": [ + 325, + 616, + 340, + 628 + ], + "score": 0.9, + "content": "| V |", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 615, + 489, + 629 + ], + "score": 1.0, + "content": "is then the count. Notice how when", + "type": "text" + }, + { + "bbox": [ + 489, + 616, + 504, + 628 + ], + "score": 0.88, + "content": "| E |", + "type": "inline_equation" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 627, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 214, + 642 + ], + "score": 1.0, + "content": "is set to the sum over A,", + "type": "text" + }, + { + "bbox": [ + 214, + 627, + 278, + 641 + ], + "score": 0.93, + "content": "{ \\sqrt { \\textstyle | E | } } = \\sum _ { i } a _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 628, + 505, + 642 + ], + "score": 1.0, + "content": "holds. This convenient property implies that when all", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 640, + 506, + 652 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 506, + 652 + ], + "score": 1.0, + "content": "proposals are fully distinct, the component can output the same as simply summing over the original", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 651, + 222, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 222, + 663 + ], + "score": 1.0, + "content": "attention weights by default.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 39.5 + }, + { + "type": "text", + "bbox": [ + 106, + 667, + 504, + 690 + ], + "lines": [ + { + "bbox": [ + 106, + 667, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 505, + 680 + ], + "score": 1.0, + "content": "There are two types of duplicate edges to eliminate to achieve our objective: intra-object edges and", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 677, + 183, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 183, + 691 + ], + "score": 1.0, + "content": "inter-object edges.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5 + }, + { + "type": "title", + "bbox": [ + 107, + 701, + 235, + 713 + ], + "lines": [ + { + "bbox": [ + 106, + 700, + 235, + 713 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 235, + 713 + ], + "score": 1.0, + "content": "4.2.1 INTRA-OBJECT EDGES", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 46 + }, + { + "type": "text", + "bbox": [ + 105, + 720, + 490, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 719, + 491, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 491, + 734 + ], + "score": 1.0, + "content": "First, we eliminate intra-object edges between duplicate proposals of a single underlying object.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 47 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 759 + ], + "lines": [] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 506, + 96 + ], + "score": 1.0, + "content": "These parameters are responsible for handling variations in attention weights and partial bounding", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 321, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 321, + 106 + ], + "score": 1.0, + "content": "box overlaps in a manner suitable for a given dataset.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 105, + 81, + 506, + 106 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 110, + 505, + 209 + ], + "lines": [ + { + "bbox": [ + 105, + 109, + 505, + 123 + ], + "spans": [ + { + "bbox": [ + 105, + 109, + 336, + 123 + ], + "score": 1.0, + "content": "To achieve this, we use several piecewise linear functions", + "type": "text" + }, + { + "bbox": [ + 336, + 111, + 378, + 122 + ], + "score": 0.93, + "content": "f _ { 1 } , \\ldots , f _ { 8 }", + "type": "inline_equation" + }, + { + "bbox": [ + 378, + 109, + 505, + 123 + ], + "score": 1.0, + "content": "as activation functions (defined", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 121, + 505, + 134 + ], + "spans": [ + { + "bbox": [ + 106, + 121, + 505, + 134 + ], + "score": 1.0, + "content": "in Appendix A), approximating arbitrary functions with domain and range [0, 1]. The shapes of", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 132, + 505, + 145 + ], + "spans": [ + { + "bbox": [ + 106, + 132, + 505, + 145 + ], + "score": 1.0, + "content": "these functions are learned to handle the specific nonlinear interactions necessary for dealing with", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 143, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 106, + 143, + 394, + 156 + ], + "score": 1.0, + "content": "overlapping proposals. Through their parametrization we enforce that", + "type": "text" + }, + { + "bbox": [ + 394, + 143, + 437, + 155 + ], + "score": 0.89, + "content": "f _ { k } ( 0 ) = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 143, + 441, + 156 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 441, + 143, + 484, + 155 + ], + "score": 0.89, + "content": "f _ { k } ( 1 ) = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 143, + 505, + 156 + ], + "score": 1.0, + "content": ", and", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 153, + 506, + 168 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 506, + 168 + ], + "score": 1.0, + "content": "that they are monotonically increasing. The first two properties are required so that the extreme cases", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 163, + 506, + 180 + ], + "spans": [ + { + "bbox": [ + 105, + 163, + 344, + 180 + ], + "score": 1.0, + "content": "that we explicitly handle are left unchanged. In those cases,", + "type": "text" + }, + { + "bbox": [ + 344, + 165, + 356, + 177 + ], + "score": 0.88, + "content": "f _ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 163, + 506, + 180 + ], + "score": 1.0, + "content": "is only applied to values of 0 or 1, so", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 177, + 506, + 189 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 506, + 189 + ], + "score": 1.0, + "content": "the activation functions can be safely ignored for understanding how the component handles them.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 188, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 106, + 188, + 505, + 200 + ], + "score": 1.0, + "content": "By enforcing monotonicity, we can make sure that, for example, an increased value in an attention", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 199, + 371, + 210 + ], + "spans": [ + { + "bbox": [ + 106, + 199, + 371, + 210 + ], + "score": 1.0, + "content": "map should never result in the prediction of the count to decrease.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6, + "bbox_fs": [ + 105, + 109, + 506, + 210 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 222, + 158, + 234 + ], + "lines": [ + { + "bbox": [ + 105, + 221, + 160, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 160, + 236 + ], + "score": 1.0, + "content": "4.1 INPUT", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 107, + 243, + 505, + 287 + ], + "lines": [ + { + "bbox": [ + 105, + 242, + 505, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 505, + 255 + ], + "score": 1.0, + "content": "Given a set of features from object proposals, an attention mechanism produces a weight for each", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 254, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 399, + 266 + ], + "score": 1.0, + "content": "proposal based on the question. The counting component takes as input the", + "type": "text" + }, + { + "bbox": [ + 400, + 256, + 407, + 263 + ], + "score": 0.71, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 254, + 505, + 266 + ], + "score": 1.0, + "content": "largest attention weights", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 107, + 264, + 505, + 279 + ], + "spans": [ + { + "bbox": [ + 107, + 264, + 180, + 277 + ], + "score": 0.92, + "content": "\\mathbf { \\bar { a } } = [ a _ { 1 } , \\ldots , a _ { n } ] ^ { \\mathsf { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 264, + 347, + 279 + ], + "score": 1.0, + "content": "and their corresponding bounding boxes", + "type": "text" + }, + { + "bbox": [ + 347, + 265, + 419, + 277 + ], + "score": 0.9, + "content": "\\mathbf { b } = [ b _ { 1 } , \\ldots , b _ { n } ] ^ { \\mathsf { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 264, + 505, + 279 + ], + "score": 1.0, + "content": ". We assume that the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 276, + 479, + 288 + ], + "spans": [ + { + "bbox": [ + 106, + 276, + 210, + 288 + ], + "score": 1.0, + "content": "weights lie in the interval", + "type": "text" + }, + { + "bbox": [ + 210, + 276, + 231, + 288 + ], + "score": 0.56, + "content": "[ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 276, + 479, + 288 + ], + "score": 1.0, + "content": ", which can easily be achieved by applying a logistic function.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13.5, + "bbox_fs": [ + 105, + 242, + 505, + 288 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 292, + 505, + 381 + ], + "lines": [ + { + "bbox": [ + 105, + 293, + 506, + 305 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 506, + 305 + ], + "score": 1.0, + "content": "In the extreme cases that we explicitly handle, we assume that the attention mechanism assigns a", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 304, + 506, + 315 + ], + "spans": [ + { + "bbox": [ + 106, + 304, + 160, + 315 + ], + "score": 1.0, + "content": "value of 1 to", + "type": "text" + }, + { + "bbox": [ + 160, + 305, + 170, + 315 + ], + "score": 0.83, + "content": "a _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 304, + 506, + 315 + ], + "score": 1.0, + "content": "whenever the ith proposal contains a relevant object and a value of 0 whenever it", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 315, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 506, + 327 + ], + "score": 1.0, + "content": "does not. This is in line with what usual soft attention mechanisms learn, as they produce higher", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 326, + 505, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 505, + 338 + ], + "score": 1.0, + "content": "weights for relevant inputs. We also assume that either two object proposals fully overlap (in which", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 336, + 505, + 349 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 505, + 349 + ], + "score": 1.0, + "content": "case they must be showing the same object and thus receive the same attention weight) or that they", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 348, + 505, + 360 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 505, + 360 + ], + "score": 1.0, + "content": "are fully distinct (in which case they show different objects). Keep in mind that while we make these", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 359, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 505, + 371 + ], + "score": 1.0, + "content": "assumptions to make reasoning about the behaviour easier, the learned parameters in the activation", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 368, + 493, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 368, + 493, + 383 + ], + "score": 1.0, + "content": "functions are intended to handle the more realistic scenarios when the assumptions do not apply.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 293, + 506, + 383 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 386, + 504, + 409 + ], + "lines": [ + { + "bbox": [ + 105, + 385, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 505, + 400 + ], + "score": 1.0, + "content": "Instead of partially overlapping proposals, the problem now becomes the handling of exact duplicate", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 397, + 343, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 343, + 410 + ], + "score": 1.0, + "content": "proposals of underlying objects in a differentiable manner.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5, + "bbox_fs": [ + 105, + 385, + 505, + 410 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 422, + 203, + 433 + ], + "lines": [ + { + "bbox": [ + 106, + 421, + 204, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 204, + 434 + ], + "score": 1.0, + "content": "4.2 DEDUPLICATION", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 442, + 504, + 476 + ], + "lines": [ + { + "bbox": [ + 105, + 441, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 506, + 455 + ], + "score": 1.0, + "content": "We start by changing the vector of attention weights a into a graph representation in which bounding", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "score": 1.0, + "content": "boxes can be utilized more easily. Hence, we compute the outer product of the attention weights to", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 465, + 214, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 465, + 214, + 475 + ], + "score": 1.0, + "content": "obtain an attention matrix.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28, + "bbox_fs": [ + 105, + 441, + 506, + 475 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 285, + 490, + 326, + 504 + ], + "lines": [ + { + "bbox": [ + 285, + 490, + 326, + 504 + ], + "spans": [ + { + "bbox": [ + 285, + 490, + 326, + 504 + ], + "score": 0.89, + "content": "\\mathbf { A } = \\mathbf { a } \\mathbf { a } ^ { \\mathsf { T } }", + "type": "interline_equation", + "image_path": "45d21d32766cf3e79ac4874ade1c995e6282fbe88bba109fb973d8aace126ef1.jpg" + } + ] + } + ], + "index": 30, + "virtual_lines": [ + { + "bbox": [ + 285, + 490, + 326, + 504 + ], + "spans": [], + "index": 30 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 511, + 504, + 566 + ], + "lines": [ + { + "bbox": [ + 106, + 509, + 506, + 525 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 152, + 522 + ], + "score": 0.9, + "content": "\\mathbf { A } \\in \\mathbb { R } ^ { n \\times n }", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 509, + 506, + 525 + ], + "score": 1.0, + "content": "can be interpreted as an adjacency matrix for a weighted directed graph. In this graph, the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 522, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 329, + 534 + ], + "score": 1.0, + "content": "ith vertex represents the object proposal associated with", + "type": "text" + }, + { + "bbox": [ + 329, + 524, + 339, + 533 + ], + "score": 0.85, + "content": "a _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 522, + 505, + 534 + ], + "score": 1.0, + "content": "and the edge between any pair of vertices", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 533, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 106, + 533, + 127, + 545 + ], + "score": 0.93, + "content": "( i , j )", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 533, + 175, + 546 + ], + "score": 1.0, + "content": "has weight", + "type": "text" + }, + { + "bbox": [ + 175, + 534, + 194, + 545 + ], + "score": 0.89, + "content": "a _ { i } a _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 195, + 533, + 309, + 546 + ], + "score": 1.0, + "content": ". In the extreme case where", + "type": "text" + }, + { + "bbox": [ + 309, + 534, + 319, + 544 + ], + "score": 0.86, + "content": "a _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 533, + 506, + 546 + ], + "score": 1.0, + "content": "is virtually 0 or 1, products are equivalent to", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 544, + 506, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 466, + 557 + ], + "score": 1.0, + "content": "logical AND operators. It follows that the subgraph containing only the vertices satisfying", + "type": "text" + }, + { + "bbox": [ + 467, + 545, + 495, + 555 + ], + "score": 0.91, + "content": "a _ { i } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 544, + 506, + 557 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 554, + 250, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 250, + 568 + ], + "score": 1.0, + "content": "a complete digraph with self-loops.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33, + "bbox_fs": [ + 105, + 509, + 506, + 568 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 571, + 505, + 662 + ], + "lines": [ + { + "bbox": [ + 105, + 570, + 505, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 505, + 585 + ], + "score": 1.0, + "content": "In this representation, our objective is to eliminate edges in such a way that, conceptually, the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 583, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 583, + 505, + 595 + ], + "score": 1.0, + "content": "underlying true objects – instead of proposals thereof – are the vertices of that complete subgraph. In", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 399, + 606 + ], + "score": 1.0, + "content": "order to then turn that graph into a count, recall that the number of edges", + "type": "text" + }, + { + "bbox": [ + 400, + 594, + 414, + 605 + ], + "score": 0.89, + "content": "| E |", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "in a complete digraph", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 603, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 303, + 618 + ], + "score": 1.0, + "content": "with self-loops relates to the number of vertices", + "type": "text" + }, + { + "bbox": [ + 303, + 605, + 318, + 617 + ], + "score": 0.88, + "content": "| V |", + "type": "inline_equation" + }, + { + "bbox": [ + 318, + 603, + 354, + 618 + ], + "score": 1.0, + "content": "through", + "type": "text" + }, + { + "bbox": [ + 354, + 605, + 400, + 617 + ], + "score": 0.76, + "content": "| E | = | V | ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 603, + 405, + 618 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 405, + 605, + 420, + 617 + ], + "score": 0.7, + "content": "| E |", + "type": "inline_equation" + }, + { + "bbox": [ + 420, + 603, + 505, + 618 + ], + "score": 1.0, + "content": "can be computed by", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 615, + 504, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 325, + 629 + ], + "score": 1.0, + "content": "summing over the entries in an adjacency matrix and", + "type": "text" + }, + { + "bbox": [ + 325, + 616, + 340, + 628 + ], + "score": 0.9, + "content": "| V |", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 615, + 489, + 629 + ], + "score": 1.0, + "content": "is then the count. Notice how when", + "type": "text" + }, + { + "bbox": [ + 489, + 616, + 504, + 628 + ], + "score": 0.88, + "content": "| E |", + "type": "inline_equation" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 627, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 214, + 642 + ], + "score": 1.0, + "content": "is set to the sum over A,", + "type": "text" + }, + { + "bbox": [ + 214, + 627, + 278, + 641 + ], + "score": 0.93, + "content": "{ \\sqrt { \\textstyle | E | } } = \\sum _ { i } a _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 628, + 505, + 642 + ], + "score": 1.0, + "content": "holds. This convenient property implies that when all", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 640, + 506, + 652 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 506, + 652 + ], + "score": 1.0, + "content": "proposals are fully distinct, the component can output the same as simply summing over the original", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 651, + 222, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 222, + 663 + ], + "score": 1.0, + "content": "attention weights by default.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 39.5, + "bbox_fs": [ + 105, + 570, + 506, + 663 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 667, + 504, + 690 + ], + "lines": [ + { + "bbox": [ + 106, + 667, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 505, + 680 + ], + "score": 1.0, + "content": "There are two types of duplicate edges to eliminate to achieve our objective: intra-object edges and", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 677, + 183, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 183, + 691 + ], + "score": 1.0, + "content": "inter-object edges.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5, + "bbox_fs": [ + 105, + 667, + 505, + 691 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 701, + 235, + 713 + ], + "lines": [ + { + "bbox": [ + 106, + 700, + 235, + 713 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 235, + 713 + ], + "score": 1.0, + "content": "4.2.1 INTRA-OBJECT EDGES", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 46 + }, + { + "type": "text", + "bbox": [ + 105, + 720, + 490, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 719, + 491, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 491, + 734 + ], + "score": 1.0, + "content": "First, we eliminate intra-object edges between duplicate proposals of a single underlying object.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 47, + "bbox_fs": [ + 105, + 719, + 491, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 185, + 83, + 426, + 148 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 185, + 83, + 426, + 148 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 185, + 83, + 426, + 148 + ], + "spans": [ + { + "bbox": [ + 185, + 83, + 426, + 148 + ], + "score": 0.964, + "type": "image", + "image_path": "ebf111b774761b74e228aac07c7d7d09a9fdfade0a9ad743d7521aa694abb69f.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 185, + 83, + 426, + 96.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 185, + 96.0, + 426, + 109.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 185, + 109.0, + 426, + 122.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 185, + 122.0, + 426, + 135.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 185, + 135.0, + 426, + 148.0 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 2 + }, + { + "type": "image", + "bbox": [ + 131, + 205, + 480, + 271 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 107, + 161, + 504, + 195 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 161, + 505, + 173 + ], + "spans": [ + { + "bbox": [ + 106, + 161, + 505, + 173 + ], + "score": 1.0, + "content": "Figure 2: Removal of intra-object edges by masking the edges of the attention matrix A with the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 172, + 505, + 185 + ], + "spans": [ + { + "bbox": [ + 106, + 172, + 505, + 185 + ], + "score": 1.0, + "content": "distance matrix D. The black vertices now form a graph without self-loops. The self-loops need to", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 182, + 199, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 182, + 199, + 195 + ], + "score": 1.0, + "content": "be added back in later.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "image_body", + "bbox": [ + 131, + 205, + 480, + 271 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 131, + 205, + 480, + 271 + ], + "spans": [ + { + "bbox": [ + 131, + 205, + 480, + 271 + ], + "score": 0.964, + "type": "image", + "image_path": "afc38c727db1f3d829ce09537e6ec8c8c604979b7eca9b190e7296a9afa5152c.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 131, + 205, + 480, + 227.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 131, + 227.0, + 480, + 249.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 131, + 249.0, + 480, + 271.0 + ], + "spans": [], + "index": 10 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 284, + 505, + 342 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 284, + 506, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 506, + 297 + ], + "score": 1.0, + "content": "Figure 3: Removal of duplicate inter-object edges by computing a scaling factor for each vertex and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 295, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 138, + 310 + ], + "score": 1.0, + "content": "scaling", + "type": "text" + }, + { + "bbox": [ + 138, + 295, + 151, + 307 + ], + "score": 0.86, + "content": "\\tilde { \\mathbf { A } } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 295, + 204, + 310 + ], + "score": 1.0, + "content": "accordingly.", + "type": "text" + }, + { + "bbox": [ + 205, + 295, + 218, + 307 + ], + "score": 0.85, + "content": "\\bar { \\mathbf { A } } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 218, + 295, + 228, + 310 + ], + "score": 1.0, + "content": "is", + "type": "text" + }, + { + "bbox": [ + 228, + 295, + 239, + 307 + ], + "score": 0.72, + "content": "\\tilde { \\mathbf { A } }", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 295, + 505, + 310 + ], + "score": 1.0, + "content": "with self-loops already added back in. The scaling factor for one", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 307, + 506, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 506, + 321 + ], + "score": 1.0, + "content": "vertex is computed by counting how many vertices have outgoing edges to the same set of vertices;", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 318, + 505, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 505, + 332 + ], + "score": 1.0, + "content": "all edges of the two proposals on the right are scaled by 0.5. This can be seen as averaging proposals", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 329, + 478, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 478, + 343 + ], + "score": 1.0, + "content": "within each object and is equivalent to removing duplicate proposals altogether under a sum.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 106, + 361, + 504, + 383 + ], + "lines": [ + { + "bbox": [ + 106, + 361, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 106, + 361, + 505, + 373 + ], + "score": 1.0, + "content": "To compare two bounding boxes, we use the usual intersection-over-union (IoU) metric. We define", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 369, + 255, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 369, + 185, + 385 + ], + "score": 1.0, + "content": "the distance matrix", + "type": "text" + }, + { + "bbox": [ + 185, + 372, + 231, + 382 + ], + "score": 0.92, + "content": "\\mathbf { D } \\in \\bar { \\mathbb { R } } ^ { n \\times n }", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 369, + 255, + 385 + ], + "score": 1.0, + "content": "to be", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16.5 + }, + { + "type": "interline_equation", + "bbox": [ + 259, + 399, + 351, + 413 + ], + "lines": [ + { + "bbox": [ + 259, + 399, + 351, + 413 + ], + "spans": [ + { + "bbox": [ + 259, + 399, + 351, + 413 + ], + "score": 0.92, + "content": "D _ { i j } = 1 - \\mathrm { I o U } ( b _ { i } , b _ { j } )", + "type": "interline_equation", + "image_path": "e17173feaf5840ff4ccb3f0036fe26270a9b13dcff514013b1adda23f4241173.jpg" + } + ] + } + ], + "index": 18, + "virtual_lines": [ + { + "bbox": [ + 259, + 399, + 351, + 413 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 420, + 505, + 443 + ], + "lines": [ + { + "bbox": [ + 106, + 419, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 117, + 431 + ], + "score": 0.26, + "content": "\\mathbf { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 419, + 505, + 433 + ], + "score": 1.0, + "content": "can also be interpreted as an adjacency matrix. It represents a graph that has edges everywhere", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 432, + 406, + 445 + ], + "spans": [ + { + "bbox": [ + 106, + 432, + 406, + 445 + ], + "score": 1.0, + "content": "except when the two bounding boxes that an edge connects would overlap.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 106, + 448, + 504, + 471 + ], + "lines": [ + { + "bbox": [ + 106, + 448, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 342, + 461 + ], + "score": 1.0, + "content": "Intra-object edges are removed by elementwise multiplying", + "type": "text" + }, + { + "bbox": [ + 342, + 450, + 356, + 460 + ], + "score": 0.71, + "content": "( \\odot )", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 448, + 505, + 461 + ], + "score": 1.0, + "content": "the distance matrix with the attention", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 459, + 179, + 471 + ], + "spans": [ + { + "bbox": [ + 106, + 459, + 179, + 471 + ], + "score": 1.0, + "content": "matrix (Figure 2).", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5 + }, + { + "type": "interline_equation", + "bbox": [ + 261, + 484, + 350, + 500 + ], + "lines": [ + { + "bbox": [ + 261, + 484, + 350, + 500 + ], + "spans": [ + { + "bbox": [ + 261, + 484, + 350, + 500 + ], + "score": 0.92, + "content": "\\tilde { \\mathbf { A } } = f _ { 1 } ( \\mathbf { A } ) \\odot f _ { 2 } ( \\mathbf { D } )", + "type": "interline_equation", + "image_path": "2c2d701d5864f3e52114d9964ac794164b7ab3bd62fc612ee934a0a81b728e32.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 261, + 484, + 350, + 500 + ], + "spans": [], + "index": 23 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 509, + 505, + 554 + ], + "lines": [ + { + "bbox": [ + 106, + 507, + 503, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 507, + 117, + 520 + ], + "score": 0.51, + "content": "\\tilde { \\mathbf { A } }", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 508, + 457, + 523 + ], + "score": 1.0, + "content": "no longer has self-loops, so we need to add them back in at a later point to still satisfy", + "type": "text" + }, + { + "bbox": [ + 457, + 509, + 503, + 522 + ], + "score": 0.93, + "content": "| E | = | V | ^ { 2 }", + "type": "inline_equation" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 521, + 506, + 533 + ], + "spans": [ + { + "bbox": [ + 106, + 521, + 506, + 533 + ], + "score": 1.0, + "content": "Notice that we start making use of the activation functions mentioned earlier to handle intermediate", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 532, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 106, + 532, + 192, + 543 + ], + "score": 1.0, + "content": "values in the interval", + "type": "text" + }, + { + "bbox": [ + 192, + 532, + 215, + 543 + ], + "score": 0.91, + "content": "( 0 , 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 532, + 279, + 543 + ], + "score": 1.0, + "content": "for both A and", + "type": "text" + }, + { + "bbox": [ + 280, + 532, + 289, + 541 + ], + "score": 0.54, + "content": "\\mathbf { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 532, + 505, + 543 + ], + "score": 1.0, + "content": ". They regulate the influence of attention weights that", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 541, + 343, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 343, + 556 + ], + "score": 1.0, + "content": "are not close to 0 or 1 and the influence of partial overlaps.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25.5 + }, + { + "type": "title", + "bbox": [ + 107, + 566, + 234, + 577 + ], + "lines": [ + { + "bbox": [ + 106, + 566, + 235, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 566, + 235, + 578 + ], + "score": 1.0, + "content": "4.2.2 INTER-OBJECT EDGES", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 108, + 585, + 504, + 597 + ], + "lines": [ + { + "bbox": [ + 106, + 585, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 585, + 505, + 599 + ], + "score": 1.0, + "content": "Second, we eliminate inter-object edges between duplicate proposals of different underlying objects.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 601, + 505, + 680 + ], + "lines": [ + { + "bbox": [ + 105, + 602, + 505, + 615 + ], + "spans": [ + { + "bbox": [ + 105, + 602, + 505, + 615 + ], + "score": 1.0, + "content": "The main idea (depicted in Figure 3) is to count the number of proposals associated to each invidual", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 613, + 505, + 626 + ], + "spans": [ + { + "bbox": [ + 106, + 613, + 505, + 626 + ], + "score": 1.0, + "content": "object, then scale down the weight of their associated edges by that number. If there are two proposals", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 624, + 505, + 637 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 505, + 637 + ], + "score": 1.0, + "content": "of a single object, the edges involving those proposals should be scaled by 0.5. In essence, this", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 636, + 505, + 648 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 505, + 648 + ], + "score": 1.0, + "content": "averages over the proposals within each underlying object because we only use the sum over the edge", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "score": 1.0, + "content": "weights to compute the count at the end. Conceptually, this reduces multiple proposals of an object", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 657, + 506, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 506, + 670 + ], + "score": 1.0, + "content": "down to one as desired. Since we do not know how many proposals belong to an object, we have to", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 669, + 455, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 669, + 455, + 680 + ], + "score": 1.0, + "content": "estimate this. We do this by using the fact that proposals of the same object are similar.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 107, + 686, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 684, + 506, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 686, + 186, + 699 + ], + "score": 1.0, + "content": "Keep in mind that", + "type": "text" + }, + { + "bbox": [ + 186, + 684, + 196, + 696 + ], + "score": 0.57, + "content": "\\tilde { \\mathbf { A } }", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 686, + 506, + 699 + ], + "score": 1.0, + "content": "has no self-loops nor edges between proposals of the same object. As a", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 697, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 248, + 711 + ], + "score": 1.0, + "content": "consequence, two nonzero rows in", + "type": "text" + }, + { + "bbox": [ + 249, + 697, + 259, + 709 + ], + "score": 0.76, + "content": "\\tilde { \\mathbf { A } }", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "are the same if and only if the proposals are the same. If the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "two rows differ in at least one entry, then one proposal overlaps a proposal that the other proposal", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 721, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 506, + 733 + ], + "score": 1.0, + "content": "does not overlap, so they must be different proposals. This means for comparing rows, we need a", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38.5 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 185, + 83, + 426, + 148 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 185, + 83, + 426, + 148 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 185, + 83, + 426, + 148 + ], + "spans": [ + { + "bbox": [ + 185, + 83, + 426, + 148 + ], + "score": 0.964, + "type": "image", + "image_path": "ebf111b774761b74e228aac07c7d7d09a9fdfade0a9ad743d7521aa694abb69f.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 185, + 83, + 426, + 96.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 185, + 96.0, + 426, + 109.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 185, + 109.0, + 426, + 122.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 185, + 122.0, + 426, + 135.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 185, + 135.0, + 426, + 148.0 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 2 + }, + { + "type": "image", + "bbox": [ + 131, + 205, + 480, + 271 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 107, + 161, + 504, + 195 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 161, + 505, + 173 + ], + "spans": [ + { + "bbox": [ + 106, + 161, + 505, + 173 + ], + "score": 1.0, + "content": "Figure 2: Removal of intra-object edges by masking the edges of the attention matrix A with the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 172, + 505, + 185 + ], + "spans": [ + { + "bbox": [ + 106, + 172, + 505, + 185 + ], + "score": 1.0, + "content": "distance matrix D. The black vertices now form a graph without self-loops. The self-loops need to", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 182, + 199, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 182, + 199, + 195 + ], + "score": 1.0, + "content": "be added back in later.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "image_body", + "bbox": [ + 131, + 205, + 480, + 271 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 131, + 205, + 480, + 271 + ], + "spans": [ + { + "bbox": [ + 131, + 205, + 480, + 271 + ], + "score": 0.964, + "type": "image", + "image_path": "afc38c727db1f3d829ce09537e6ec8c8c604979b7eca9b190e7296a9afa5152c.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 131, + 205, + 480, + 227.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 131, + 227.0, + 480, + 249.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 131, + 249.0, + 480, + 271.0 + ], + "spans": [], + "index": 10 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 284, + 505, + 342 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 284, + 506, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 506, + 297 + ], + "score": 1.0, + "content": "Figure 3: Removal of duplicate inter-object edges by computing a scaling factor for each vertex and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 295, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 138, + 310 + ], + "score": 1.0, + "content": "scaling", + "type": "text" + }, + { + "bbox": [ + 138, + 295, + 151, + 307 + ], + "score": 0.86, + "content": "\\tilde { \\mathbf { A } } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 295, + 204, + 310 + ], + "score": 1.0, + "content": "accordingly.", + "type": "text" + }, + { + "bbox": [ + 205, + 295, + 218, + 307 + ], + "score": 0.85, + "content": "\\bar { \\mathbf { A } } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 218, + 295, + 228, + 310 + ], + "score": 1.0, + "content": "is", + "type": "text" + }, + { + "bbox": [ + 228, + 295, + 239, + 307 + ], + "score": 0.72, + "content": "\\tilde { \\mathbf { A } }", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 295, + 505, + 310 + ], + "score": 1.0, + "content": "with self-loops already added back in. The scaling factor for one", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 307, + 506, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 506, + 321 + ], + "score": 1.0, + "content": "vertex is computed by counting how many vertices have outgoing edges to the same set of vertices;", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 318, + 505, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 505, + 332 + ], + "score": 1.0, + "content": "all edges of the two proposals on the right are scaled by 0.5. This can be seen as averaging proposals", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 329, + 478, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 478, + 343 + ], + "score": 1.0, + "content": "within each object and is equivalent to removing duplicate proposals altogether under a sum.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 106, + 361, + 504, + 383 + ], + "lines": [ + { + "bbox": [ + 106, + 361, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 106, + 361, + 505, + 373 + ], + "score": 1.0, + "content": "To compare two bounding boxes, we use the usual intersection-over-union (IoU) metric. We define", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 369, + 255, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 369, + 185, + 385 + ], + "score": 1.0, + "content": "the distance matrix", + "type": "text" + }, + { + "bbox": [ + 185, + 372, + 231, + 382 + ], + "score": 0.92, + "content": "\\mathbf { D } \\in \\bar { \\mathbb { R } } ^ { n \\times n }", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 369, + 255, + 385 + ], + "score": 1.0, + "content": "to be", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16.5, + "bbox_fs": [ + 105, + 361, + 505, + 385 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 259, + 399, + 351, + 413 + ], + "lines": [ + { + "bbox": [ + 259, + 399, + 351, + 413 + ], + "spans": [ + { + "bbox": [ + 259, + 399, + 351, + 413 + ], + "score": 0.92, + "content": "D _ { i j } = 1 - \\mathrm { I o U } ( b _ { i } , b _ { j } )", + "type": "interline_equation", + "image_path": "e17173feaf5840ff4ccb3f0036fe26270a9b13dcff514013b1adda23f4241173.jpg" + } + ] + } + ], + "index": 18, + "virtual_lines": [ + { + "bbox": [ + 259, + 399, + 351, + 413 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 420, + 505, + 443 + ], + "lines": [ + { + "bbox": [ + 106, + 419, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 117, + 431 + ], + "score": 0.26, + "content": "\\mathbf { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 419, + 505, + 433 + ], + "score": 1.0, + "content": "can also be interpreted as an adjacency matrix. It represents a graph that has edges everywhere", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 432, + 406, + 445 + ], + "spans": [ + { + "bbox": [ + 106, + 432, + 406, + 445 + ], + "score": 1.0, + "content": "except when the two bounding boxes that an edge connects would overlap.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5, + "bbox_fs": [ + 106, + 419, + 505, + 445 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 448, + 504, + 471 + ], + "lines": [ + { + "bbox": [ + 106, + 448, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 342, + 461 + ], + "score": 1.0, + "content": "Intra-object edges are removed by elementwise multiplying", + "type": "text" + }, + { + "bbox": [ + 342, + 450, + 356, + 460 + ], + "score": 0.71, + "content": "( \\odot )", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 448, + 505, + 461 + ], + "score": 1.0, + "content": "the distance matrix with the attention", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 459, + 179, + 471 + ], + "spans": [ + { + "bbox": [ + 106, + 459, + 179, + 471 + ], + "score": 1.0, + "content": "matrix (Figure 2).", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5, + "bbox_fs": [ + 106, + 448, + 505, + 471 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 261, + 484, + 350, + 500 + ], + "lines": [ + { + "bbox": [ + 261, + 484, + 350, + 500 + ], + "spans": [ + { + "bbox": [ + 261, + 484, + 350, + 500 + ], + "score": 0.92, + "content": "\\tilde { \\mathbf { A } } = f _ { 1 } ( \\mathbf { A } ) \\odot f _ { 2 } ( \\mathbf { D } )", + "type": "interline_equation", + "image_path": "2c2d701d5864f3e52114d9964ac794164b7ab3bd62fc612ee934a0a81b728e32.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 261, + 484, + 350, + 500 + ], + "spans": [], + "index": 23 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 509, + 505, + 554 + ], + "lines": [ + { + "bbox": [ + 106, + 507, + 503, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 507, + 117, + 520 + ], + "score": 0.51, + "content": "\\tilde { \\mathbf { A } }", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 508, + 457, + 523 + ], + "score": 1.0, + "content": "no longer has self-loops, so we need to add them back in at a later point to still satisfy", + "type": "text" + }, + { + "bbox": [ + 457, + 509, + 503, + 522 + ], + "score": 0.93, + "content": "| E | = | V | ^ { 2 }", + "type": "inline_equation" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 521, + 506, + 533 + ], + "spans": [ + { + "bbox": [ + 106, + 521, + 506, + 533 + ], + "score": 1.0, + "content": "Notice that we start making use of the activation functions mentioned earlier to handle intermediate", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 532, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 106, + 532, + 192, + 543 + ], + "score": 1.0, + "content": "values in the interval", + "type": "text" + }, + { + "bbox": [ + 192, + 532, + 215, + 543 + ], + "score": 0.91, + "content": "( 0 , 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 532, + 279, + 543 + ], + "score": 1.0, + "content": "for both A and", + "type": "text" + }, + { + "bbox": [ + 280, + 532, + 289, + 541 + ], + "score": 0.54, + "content": "\\mathbf { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 532, + 505, + 543 + ], + "score": 1.0, + "content": ". They regulate the influence of attention weights that", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 541, + 343, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 343, + 556 + ], + "score": 1.0, + "content": "are not close to 0 or 1 and the influence of partial overlaps.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25.5, + "bbox_fs": [ + 105, + 507, + 506, + 556 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 566, + 234, + 577 + ], + "lines": [ + { + "bbox": [ + 106, + 566, + 235, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 566, + 235, + 578 + ], + "score": 1.0, + "content": "4.2.2 INTER-OBJECT EDGES", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 108, + 585, + 504, + 597 + ], + "lines": [ + { + "bbox": [ + 106, + 585, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 585, + 505, + 599 + ], + "score": 1.0, + "content": "Second, we eliminate inter-object edges between duplicate proposals of different underlying objects.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29, + "bbox_fs": [ + 106, + 585, + 505, + 599 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 601, + 505, + 680 + ], + "lines": [ + { + "bbox": [ + 105, + 602, + 505, + 615 + ], + "spans": [ + { + "bbox": [ + 105, + 602, + 505, + 615 + ], + "score": 1.0, + "content": "The main idea (depicted in Figure 3) is to count the number of proposals associated to each invidual", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 613, + 505, + 626 + ], + "spans": [ + { + "bbox": [ + 106, + 613, + 505, + 626 + ], + "score": 1.0, + "content": "object, then scale down the weight of their associated edges by that number. If there are two proposals", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 624, + 505, + 637 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 505, + 637 + ], + "score": 1.0, + "content": "of a single object, the edges involving those proposals should be scaled by 0.5. In essence, this", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 636, + 505, + 648 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 505, + 648 + ], + "score": 1.0, + "content": "averages over the proposals within each underlying object because we only use the sum over the edge", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "score": 1.0, + "content": "weights to compute the count at the end. Conceptually, this reduces multiple proposals of an object", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 657, + 506, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 506, + 670 + ], + "score": 1.0, + "content": "down to one as desired. Since we do not know how many proposals belong to an object, we have to", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 669, + 455, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 669, + 455, + 680 + ], + "score": 1.0, + "content": "estimate this. We do this by using the fact that proposals of the same object are similar.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 33, + "bbox_fs": [ + 105, + 602, + 506, + 680 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 686, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 684, + 506, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 686, + 186, + 699 + ], + "score": 1.0, + "content": "Keep in mind that", + "type": "text" + }, + { + "bbox": [ + 186, + 684, + 196, + 696 + ], + "score": 0.57, + "content": "\\tilde { \\mathbf { A } }", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 686, + 506, + 699 + ], + "score": 1.0, + "content": "has no self-loops nor edges between proposals of the same object. As a", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 697, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 248, + 711 + ], + "score": 1.0, + "content": "consequence, two nonzero rows in", + "type": "text" + }, + { + "bbox": [ + 249, + 697, + 259, + 709 + ], + "score": 0.76, + "content": "\\tilde { \\mathbf { A } }", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "are the same if and only if the proposals are the same. If the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "two rows differ in at least one entry, then one proposal overlaps a proposal that the other proposal", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 721, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 506, + 733 + ], + "score": 1.0, + "content": "does not overlap, so they must be different proposals. This means for comparing rows, we need a", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "similarity function that satisfies the criteria of taking the value 1 when they differ in no places and 0", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 464, + 107 + ], + "score": 1.0, + "content": "if they differ in at least one place. We define a differentiable similarity between proposals", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 464, + 95, + 469, + 104 + ], + "score": 0.75, + "content": "i", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 469, + 93, + 487, + 107 + ], + "score": 1.0, + "content": "and", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 487, + 94, + 493, + 105 + ], + "score": 0.83, + "content": "j", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 493, + 93, + 505, + 107 + ], + "score": 1.0, + "content": "as", + "type": "text", + "cross_page": true + } + ], + "index": 1 + } + ], + "index": 38.5, + "bbox_fs": [ + 105, + 684, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 505, + 106 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "similarity function that satisfies the criteria of taking the value 1 when they differ in no places and 0", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 464, + 107 + ], + "score": 1.0, + "content": "if they differ in at least one place. We define a differentiable similarity between proposals", + "type": "text" + }, + { + "bbox": [ + 464, + 95, + 469, + 104 + ], + "score": 0.75, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 469, + 93, + 487, + 107 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 487, + 94, + 493, + 105 + ], + "score": 0.83, + "content": "j", + "type": "inline_equation" + }, + { + "bbox": [ + 493, + 93, + 505, + 107 + ], + "score": 1.0, + "content": "as", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "interline_equation", + "bbox": [ + 200, + 120, + 411, + 147 + ], + "lines": [ + { + "bbox": [ + 200, + 120, + 411, + 147 + ], + "spans": [ + { + "bbox": [ + 200, + 120, + 411, + 147 + ], + "score": 0.92, + "content": "\\mathrm { S i m } _ { i j } = f _ { 3 } ( 1 - | a _ { i } - a _ { j } | ) \\prod _ { k } f _ { 3 } ( 1 - | X _ { i k } - X _ { j k } | )", + "type": "interline_equation", + "image_path": "df2beb019f6e78886f4c0f3253d9ce6a6d36b7087d2fbfc8426323e8796c19a7.jpg" + } + ] + } + ], + "index": 2.5, + "virtual_lines": [ + { + "bbox": [ + 200, + 120, + 411, + 133.5 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 200, + 133.5, + 411, + 147.0 + ], + "spans": [], + "index": 3 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 153, + 505, + 188 + ], + "lines": [ + { + "bbox": [ + 106, + 152, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 154, + 132, + 167 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 154, + 219, + 167 + ], + "score": 0.92, + "content": "\\mathbf { X } = f _ { 4 } ( \\mathbf { A } ) \\odot f _ { 5 } ( \\mathbf { D } )", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 154, + 277, + 167 + ], + "score": 1.0, + "content": "is the same as", + "type": "text" + }, + { + "bbox": [ + 278, + 152, + 288, + 165 + ], + "score": 0.81, + "content": "\\tilde { \\mathbf { A } }", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 154, + 473, + 167 + ], + "score": 1.0, + "content": "except with different activation functions. The", + "type": "text" + }, + { + "bbox": [ + 473, + 154, + 483, + 167 + ], + "score": 0.85, + "content": "\\prod", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 154, + 505, + 167 + ], + "score": 1.0, + "content": "term", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 165, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 106, + 165, + 235, + 178 + ], + "score": 1.0, + "content": "compares the rows of proposals", + "type": "text" + }, + { + "bbox": [ + 235, + 166, + 240, + 175 + ], + "score": 0.79, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 165, + 258, + 178 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 258, + 166, + 264, + 177 + ], + "score": 0.81, + "content": "j", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 165, + 375, + 178 + ], + "score": 1.0, + "content": ". Using this term instead of", + "type": "text" + }, + { + "bbox": [ + 375, + 165, + 425, + 177 + ], + "score": 0.92, + "content": "f _ { 4 } ( 1 - D _ { i j } )", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 165, + 505, + 178 + ], + "score": 1.0, + "content": "was more robust to", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 176, + 306, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 306, + 189 + ], + "score": 1.0, + "content": "inaccurate bounding boxes in initial experiments.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 106, + 192, + 505, + 238 + ], + "lines": [ + { + "bbox": [ + 105, + 191, + 506, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 164, + 207 + ], + "score": 1.0, + "content": "Note that the", + "type": "text" + }, + { + "bbox": [ + 165, + 193, + 238, + 205 + ], + "score": 0.92, + "content": "f _ { 3 } ( 1 - | a _ { i } - a _ { j } | )", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 191, + 506, + 207 + ], + "score": 1.0, + "content": "term handles the edge case when there is only one proposal to", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 204, + 505, + 217 + ], + "spans": [ + { + "bbox": [ + 106, + 205, + 159, + 217 + ], + "score": 1.0, + "content": "count. Since", + "type": "text" + }, + { + "bbox": [ + 160, + 205, + 170, + 214 + ], + "score": 0.49, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 205, + 273, + 217 + ], + "score": 1.0, + "content": "does not have self-loops,", + "type": "text" + }, + { + "bbox": [ + 274, + 204, + 284, + 214 + ], + "score": 0.54, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 205, + 505, + 217 + ], + "score": 1.0, + "content": "contains only zeros in that case, which causes the row", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 215, + 505, + 228 + ], + "spans": [ + { + "bbox": [ + 106, + 215, + 178, + 228 + ], + "score": 1.0, + "content": "corresponding to", + "type": "text" + }, + { + "bbox": [ + 178, + 216, + 207, + 226 + ], + "score": 0.91, + "content": "a _ { i } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 215, + 385, + 228 + ], + "score": 1.0, + "content": "to be incorrectly similar to the rows where", + "type": "text" + }, + { + "bbox": [ + 385, + 216, + 424, + 227 + ], + "score": 0.91, + "content": "a _ { j \\neq i } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 215, + 505, + 228 + ], + "score": 1.0, + "content": ". By comparing the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 227, + 367, + 239 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 367, + 239 + ], + "score": 1.0, + "content": "attention weights through that term as well, this issue is avoided.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 105, + 243, + 504, + 266 + ], + "lines": [ + { + "bbox": [ + 106, + 243, + 505, + 255 + ], + "spans": [ + { + "bbox": [ + 106, + 243, + 505, + 255 + ], + "score": 1.0, + "content": "Now that we can check how similar two proposals are, we count the number of times any row is the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 254, + 395, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 254, + 315, + 266 + ], + "score": 1.0, + "content": "same as any other row and compute a scaling factor", + "type": "text" + }, + { + "bbox": [ + 315, + 256, + 324, + 265 + ], + "score": 0.87, + "content": "s _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 254, + 387, + 266 + ], + "score": 1.0, + "content": "for each vertex", + "type": "text" + }, + { + "bbox": [ + 387, + 255, + 392, + 264 + ], + "score": 0.63, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 254, + 395, + 266 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + }, + { + "type": "interline_equation", + "bbox": [ + 268, + 280, + 343, + 308 + ], + "lines": [ + { + "bbox": [ + 268, + 280, + 343, + 308 + ], + "spans": [ + { + "bbox": [ + 268, + 280, + 343, + 308 + ], + "score": 0.95, + "content": "s _ { i } = 1 / \\sum _ { j } \\mathrm { S i m } _ { i j }", + "type": "interline_equation", + "image_path": "efbc47996a76c7bfd2142cf8cdde1c5a64c1cfa1f607e7ef1bf94de3ee8043b5.jpg" + } + ] + } + ], + "index": 13.5, + "virtual_lines": [ + { + "bbox": [ + 268, + 280, + 343, + 294.0 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 268, + 294.0, + 343, + 308.0 + ], + "spans": [], + "index": 14 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 320, + 505, + 344 + ], + "lines": [ + { + "bbox": [ + 104, + 318, + 505, + 335 + ], + "spans": [ + { + "bbox": [ + 104, + 318, + 244, + 335 + ], + "score": 1.0, + "content": "The time complexity of computing", + "type": "text" + }, + { + "bbox": [ + 244, + 320, + 315, + 333 + ], + "score": 0.93, + "content": "\\mathbf { s } = [ s _ { 1 } , \\ldots , s _ { n } ] ^ { \\mathsf { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 318, + 325, + 335 + ], + "score": 1.0, + "content": "is", + "type": "text" + }, + { + "bbox": [ + 326, + 321, + 352, + 333 + ], + "score": 0.92, + "content": "\\Theta ( n ^ { 3 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 353, + 318, + 400, + 335 + ], + "score": 1.0, + "content": "as there are", + "type": "text" + }, + { + "bbox": [ + 400, + 321, + 412, + 331 + ], + "score": 0.88, + "content": "n ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 412, + 318, + 482, + 335 + ], + "score": 1.0, + "content": "pairs of rows and", + "type": "text" + }, + { + "bbox": [ + 483, + 321, + 505, + 333 + ], + "score": 0.91, + "content": "\\Theta ( n )", + "type": "inline_equation" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 331, + 334, + 344 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 334, + 344 + ], + "score": 1.0, + "content": "operations to compute the similarity of any pair of rows.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 106, + 348, + 505, + 383 + ], + "lines": [ + { + "bbox": [ + 105, + 348, + 506, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 506, + 362 + ], + "score": 1.0, + "content": "Since these scaling factors apply to each vertex, we have to expand s into a matrix using the outer", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 360, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 106, + 360, + 505, + 373 + ], + "score": 1.0, + "content": "product in order to scale both incoming and outgoing edges of each vertex. We can also add self-loops", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 371, + 405, + 383 + ], + "spans": [ + { + "bbox": [ + 106, + 371, + 384, + 383 + ], + "score": 1.0, + "content": "back in, which need to be scaled by s as well. Then, the count matrix", + "type": "text" + }, + { + "bbox": [ + 385, + 371, + 394, + 381 + ], + "score": 0.73, + "content": "\\mathbf { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 394, + 371, + 405, + 383 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "interline_equation", + "bbox": [ + 228, + 398, + 382, + 415 + ], + "lines": [ + { + "bbox": [ + 228, + 398, + 382, + 415 + ], + "spans": [ + { + "bbox": [ + 228, + 398, + 382, + 415 + ], + "score": 0.91, + "content": "\\mathbf { C } = \\tilde { \\mathbf { A } } \\odot \\mathbf { s s } ^ { \\mathsf { T } } + \\mathrm { { d i a g } } ( \\mathbf { s } \\odot f _ { 1 } ( \\mathbf { a } \\odot \\mathbf { a } ) )", + "type": "interline_equation", + "image_path": "a8773de135a8cbfd0753c09ba2918aff0ae26c0010d20af34943639f7db57f6b.jpg" + } + ] + } + ], + "index": 20, + "virtual_lines": [ + { + "bbox": [ + 228, + 398, + 382, + 415 + ], + "spans": [], + "index": 20 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 425, + 451, + 437 + ], + "lines": [ + { + "bbox": [ + 106, + 424, + 451, + 439 + ], + "spans": [ + { + "bbox": [ + 106, + 424, + 133, + 439 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 425, + 162, + 438 + ], + "score": 0.7, + "content": "\\mathrm { d i a g ( \\cdot ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 424, + 451, + 439 + ], + "score": 1.0, + "content": "expands a vector into a diagonal matrix with the vector on the diagonal.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 106, + 442, + 506, + 489 + ], + "lines": [ + { + "bbox": [ + 106, + 442, + 505, + 454 + ], + "spans": [ + { + "bbox": [ + 106, + 442, + 505, + 454 + ], + "score": 1.0, + "content": "The scaling of self-loops involves a non-obvious detail. Recall that the diagonal that was removed", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 453, + 506, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 179, + 468 + ], + "score": 1.0, + "content": "when going from", + "type": "text" + }, + { + "bbox": [ + 180, + 455, + 189, + 465 + ], + "score": 0.27, + "content": "\\mathbf { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 454, + 201, + 468 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 201, + 453, + 212, + 465 + ], + "score": 0.8, + "content": "\\tilde { \\mathbf { A } }", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 454, + 294, + 468 + ], + "score": 1.0, + "content": "contains the entries", + "type": "text" + }, + { + "bbox": [ + 294, + 454, + 336, + 467 + ], + "score": 0.93, + "content": "f _ { 1 } ( \\mathbf { a } \\odot \\mathbf { a } )", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 454, + 506, + 468 + ], + "score": 1.0, + "content": ". Notice however that we are scaling this", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 466, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 203, + 478 + ], + "score": 1.0, + "content": "diagonal by s and not s", + "type": "text" + }, + { + "bbox": [ + 204, + 467, + 213, + 477 + ], + "score": 0.76, + "content": "\\odot", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 466, + 505, + 478 + ], + "score": 1.0, + "content": "s. This is because the number of inter-object edges scales quadratically", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 476, + 506, + 490 + ], + "spans": [ + { + "bbox": [ + 105, + 476, + 506, + 490 + ], + "score": 1.0, + "content": "with respect to the number of proposals per object, but the number of self-loops only scales linearly.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5 + }, + { + "type": "title", + "bbox": [ + 106, + 504, + 168, + 515 + ], + "lines": [ + { + "bbox": [ + 105, + 502, + 169, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 169, + 516 + ], + "score": 1.0, + "content": "4.3 OUTPUT", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 525, + 504, + 548 + ], + "lines": [ + { + "bbox": [ + 106, + 525, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 106, + 525, + 165, + 538 + ], + "score": 1.0, + "content": "Under a sum,", + "type": "text" + }, + { + "bbox": [ + 165, + 525, + 175, + 536 + ], + "score": 0.7, + "content": "\\mathbf { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 525, + 505, + 538 + ], + "score": 1.0, + "content": "is now equivalent to a complete graph with self-loops that involves all relevant", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 536, + 339, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 536, + 339, + 549 + ], + "score": 1.0, + "content": "objects instead of relevant proposals as originally desired.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 106, + 552, + 372, + 567 + ], + "lines": [ + { + "bbox": [ + 104, + 551, + 373, + 568 + ], + "spans": [ + { + "bbox": [ + 104, + 551, + 137, + 568 + ], + "score": 1.0, + "content": "To turn", + "type": "text" + }, + { + "bbox": [ + 138, + 554, + 147, + 563 + ], + "score": 0.58, + "content": "\\mathbf { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 147, + 551, + 198, + 568 + ], + "score": 1.0, + "content": "into a count", + "type": "text" + }, + { + "bbox": [ + 198, + 556, + 203, + 563 + ], + "score": 0.68, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 204, + 551, + 234, + 568 + ], + "score": 1.0, + "content": ", we set", + "type": "text" + }, + { + "bbox": [ + 235, + 552, + 298, + 567 + ], + "score": 0.93, + "content": "\\begin{array} { r } { | E | = \\sum _ { i , j } C _ { i j } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 299, + 551, + 373, + 568 + ], + "score": 1.0, + "content": "as mentioned and", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "interline_equation", + "bbox": [ + 270, + 574, + 341, + 590 + ], + "lines": [ + { + "bbox": [ + 270, + 574, + 341, + 590 + ], + "spans": [ + { + "bbox": [ + 270, + 574, + 341, + 590 + ], + "score": 0.92, + "content": "c = | V | = \\sqrt { | E | }", + "type": "interline_equation", + "image_path": "642d05cd0b486f94409c6bd6c12f032c0238a4fd56a467acc8fb930fe3c9000b.jpg" + } + ] + } + ], + "index": 30, + "virtual_lines": [ + { + "bbox": [ + 270, + 574, + 341, + 590 + ], + "spans": [], + "index": 30 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 603, + 505, + 626 + ], + "lines": [ + { + "bbox": [ + 106, + 603, + 505, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 603, + 401, + 615 + ], + "score": 1.0, + "content": "We verified experimentally that when our extreme case assumptions hold,", + "type": "text" + }, + { + "bbox": [ + 401, + 606, + 407, + 613 + ], + "score": 0.74, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 603, + 505, + 615 + ], + "score": 1.0, + "content": "is always an integer and", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 614, + 433, + 627 + ], + "spans": [ + { + "bbox": [ + 106, + 614, + 433, + 627 + ], + "score": 1.0, + "content": "equal to the correct count, regardless of the number of duplicate object proposals.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31.5 + }, + { + "type": "text", + "bbox": [ + 106, + 631, + 505, + 665 + ], + "lines": [ + { + "bbox": [ + 105, + 630, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 505, + 644 + ], + "score": 1.0, + "content": "To avoid issues with scale when the number of objects is large, we turn this single feature into several", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 642, + 504, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 642, + 496, + 654 + ], + "score": 1.0, + "content": "classes, one for each possible number. Since we only used the object proposals with the largest", + "type": "text" + }, + { + "bbox": [ + 497, + 644, + 504, + 652 + ], + "score": 0.73, + "content": "n", + "type": "inline_equation" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 652, + 495, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 221, + 666 + ], + "score": 1.0, + "content": "weights, the predicted count", + "type": "text" + }, + { + "bbox": [ + 221, + 655, + 227, + 663 + ], + "score": 0.72, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 652, + 288, + 666 + ], + "score": 1.0, + "content": "can be at most", + "type": "text" + }, + { + "bbox": [ + 288, + 655, + 295, + 663 + ], + "score": 0.74, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 652, + 384, + 666 + ], + "score": 1.0, + "content": ". We define the output", + "type": "text" + }, + { + "bbox": [ + 384, + 653, + 470, + 665 + ], + "score": 0.93, + "content": "\\mathbf { o } ^ { \\mathsf { ^ { - } } } = [ o _ { 0 } , o _ { 1 } , \\ldots , o _ { n } ] ^ { \\mathsf { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 652, + 495, + 666 + ], + "score": 1.0, + "content": "to be", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34 + }, + { + "type": "interline_equation", + "bbox": [ + 254, + 672, + 357, + 685 + ], + "lines": [ + { + "bbox": [ + 254, + 672, + 357, + 685 + ], + "spans": [ + { + "bbox": [ + 254, + 672, + 357, + 685 + ], + "score": 0.91, + "content": "o _ { i } = \\operatorname* { m a x } ( 0 , 1 - | c - i | )", + "type": "interline_equation", + "image_path": "ce3db8dd9abdf02d670c56ed54df93933685a0172f09abb3c9f5ab60cc58665b.jpg" + } + ] + } + ], + "index": 36, + "virtual_lines": [ + { + "bbox": [ + 254, + 672, + 357, + 685 + ], + "spans": [], + "index": 36 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 698, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 446, + 711 + ], + "score": 1.0, + "content": "This results in a vector that is 1 at the index of the count and 0 everywhere else when", + "type": "text" + }, + { + "bbox": [ + 446, + 701, + 452, + 709 + ], + "score": 0.77, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "is exactly an", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "integer, and a linear interpolation between the two corresponding one-hot vectors when the count", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 720, + 223, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 223, + 734 + ], + "score": 1.0, + "content": "falls inbetween two integers.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 26, + 293, + 38 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 310, + 761 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 310, + 761 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 505, + 106 + ], + "lines": [], + "index": 0.5, + "bbox_fs": [ + 105, + 82, + 505, + 107 + ], + "lines_deleted": true + }, + { + "type": "interline_equation", + "bbox": [ + 200, + 120, + 411, + 147 + ], + "lines": [ + { + "bbox": [ + 200, + 120, + 411, + 147 + ], + "spans": [ + { + "bbox": [ + 200, + 120, + 411, + 147 + ], + "score": 0.92, + "content": "\\mathrm { S i m } _ { i j } = f _ { 3 } ( 1 - | a _ { i } - a _ { j } | ) \\prod _ { k } f _ { 3 } ( 1 - | X _ { i k } - X _ { j k } | )", + "type": "interline_equation", + "image_path": "df2beb019f6e78886f4c0f3253d9ce6a6d36b7087d2fbfc8426323e8796c19a7.jpg" + } + ] + } + ], + "index": 2.5, + "virtual_lines": [ + { + "bbox": [ + 200, + 120, + 411, + 133.5 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 200, + 133.5, + 411, + 147.0 + ], + "spans": [], + "index": 3 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 153, + 505, + 188 + ], + "lines": [ + { + "bbox": [ + 106, + 152, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 154, + 132, + 167 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 154, + 219, + 167 + ], + "score": 0.92, + "content": "\\mathbf { X } = f _ { 4 } ( \\mathbf { A } ) \\odot f _ { 5 } ( \\mathbf { D } )", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 154, + 277, + 167 + ], + "score": 1.0, + "content": "is the same as", + "type": "text" + }, + { + "bbox": [ + 278, + 152, + 288, + 165 + ], + "score": 0.81, + "content": "\\tilde { \\mathbf { A } }", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 154, + 473, + 167 + ], + "score": 1.0, + "content": "except with different activation functions. The", + "type": "text" + }, + { + "bbox": [ + 473, + 154, + 483, + 167 + ], + "score": 0.85, + "content": "\\prod", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 154, + 505, + 167 + ], + "score": 1.0, + "content": "term", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 165, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 106, + 165, + 235, + 178 + ], + "score": 1.0, + "content": "compares the rows of proposals", + "type": "text" + }, + { + "bbox": [ + 235, + 166, + 240, + 175 + ], + "score": 0.79, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 165, + 258, + 178 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 258, + 166, + 264, + 177 + ], + "score": 0.81, + "content": "j", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 165, + 375, + 178 + ], + "score": 1.0, + "content": ". Using this term instead of", + "type": "text" + }, + { + "bbox": [ + 375, + 165, + 425, + 177 + ], + "score": 0.92, + "content": "f _ { 4 } ( 1 - D _ { i j } )", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 165, + 505, + 178 + ], + "score": 1.0, + "content": "was more robust to", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 176, + 306, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 306, + 189 + ], + "score": 1.0, + "content": "inaccurate bounding boxes in initial experiments.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5, + "bbox_fs": [ + 105, + 152, + 505, + 189 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 192, + 505, + 238 + ], + "lines": [ + { + "bbox": [ + 105, + 191, + 506, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 164, + 207 + ], + "score": 1.0, + "content": "Note that the", + "type": "text" + }, + { + "bbox": [ + 165, + 193, + 238, + 205 + ], + "score": 0.92, + "content": "f _ { 3 } ( 1 - | a _ { i } - a _ { j } | )", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 191, + 506, + 207 + ], + "score": 1.0, + "content": "term handles the edge case when there is only one proposal to", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 204, + 505, + 217 + ], + "spans": [ + { + "bbox": [ + 106, + 205, + 159, + 217 + ], + "score": 1.0, + "content": "count. Since", + "type": "text" + }, + { + "bbox": [ + 160, + 205, + 170, + 214 + ], + "score": 0.49, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 205, + 273, + 217 + ], + "score": 1.0, + "content": "does not have self-loops,", + "type": "text" + }, + { + "bbox": [ + 274, + 204, + 284, + 214 + ], + "score": 0.54, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 205, + 505, + 217 + ], + "score": 1.0, + "content": "contains only zeros in that case, which causes the row", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 215, + 505, + 228 + ], + "spans": [ + { + "bbox": [ + 106, + 215, + 178, + 228 + ], + "score": 1.0, + "content": "corresponding to", + "type": "text" + }, + { + "bbox": [ + 178, + 216, + 207, + 226 + ], + "score": 0.91, + "content": "a _ { i } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 215, + 385, + 228 + ], + "score": 1.0, + "content": "to be incorrectly similar to the rows where", + "type": "text" + }, + { + "bbox": [ + 385, + 216, + 424, + 227 + ], + "score": 0.91, + "content": "a _ { j \\neq i } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 215, + 505, + 228 + ], + "score": 1.0, + "content": ". By comparing the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 227, + 367, + 239 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 367, + 239 + ], + "score": 1.0, + "content": "attention weights through that term as well, this issue is avoided.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 191, + 506, + 239 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 243, + 504, + 266 + ], + "lines": [ + { + "bbox": [ + 106, + 243, + 505, + 255 + ], + "spans": [ + { + "bbox": [ + 106, + 243, + 505, + 255 + ], + "score": 1.0, + "content": "Now that we can check how similar two proposals are, we count the number of times any row is the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 254, + 395, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 254, + 315, + 266 + ], + "score": 1.0, + "content": "same as any other row and compute a scaling factor", + "type": "text" + }, + { + "bbox": [ + 315, + 256, + 324, + 265 + ], + "score": 0.87, + "content": "s _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 254, + 387, + 266 + ], + "score": 1.0, + "content": "for each vertex", + "type": "text" + }, + { + "bbox": [ + 387, + 255, + 392, + 264 + ], + "score": 0.63, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 254, + 395, + 266 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5, + "bbox_fs": [ + 106, + 243, + 505, + 266 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 268, + 280, + 343, + 308 + ], + "lines": [ + { + "bbox": [ + 268, + 280, + 343, + 308 + ], + "spans": [ + { + "bbox": [ + 268, + 280, + 343, + 308 + ], + "score": 0.95, + "content": "s _ { i } = 1 / \\sum _ { j } \\mathrm { S i m } _ { i j }", + "type": "interline_equation", + "image_path": "efbc47996a76c7bfd2142cf8cdde1c5a64c1cfa1f607e7ef1bf94de3ee8043b5.jpg" + } + ] + } + ], + "index": 13.5, + "virtual_lines": [ + { + "bbox": [ + 268, + 280, + 343, + 294.0 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 268, + 294.0, + 343, + 308.0 + ], + "spans": [], + "index": 14 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 320, + 505, + 344 + ], + "lines": [ + { + "bbox": [ + 104, + 318, + 505, + 335 + ], + "spans": [ + { + "bbox": [ + 104, + 318, + 244, + 335 + ], + "score": 1.0, + "content": "The time complexity of computing", + "type": "text" + }, + { + "bbox": [ + 244, + 320, + 315, + 333 + ], + "score": 0.93, + "content": "\\mathbf { s } = [ s _ { 1 } , \\ldots , s _ { n } ] ^ { \\mathsf { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 318, + 325, + 335 + ], + "score": 1.0, + "content": "is", + "type": "text" + }, + { + "bbox": [ + 326, + 321, + 352, + 333 + ], + "score": 0.92, + "content": "\\Theta ( n ^ { 3 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 353, + 318, + 400, + 335 + ], + "score": 1.0, + "content": "as there are", + "type": "text" + }, + { + "bbox": [ + 400, + 321, + 412, + 331 + ], + "score": 0.88, + "content": "n ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 412, + 318, + 482, + 335 + ], + "score": 1.0, + "content": "pairs of rows and", + "type": "text" + }, + { + "bbox": [ + 483, + 321, + 505, + 333 + ], + "score": 0.91, + "content": "\\Theta ( n )", + "type": "inline_equation" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 331, + 334, + 344 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 334, + 344 + ], + "score": 1.0, + "content": "operations to compute the similarity of any pair of rows.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5, + "bbox_fs": [ + 104, + 318, + 505, + 344 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 348, + 505, + 383 + ], + "lines": [ + { + "bbox": [ + 105, + 348, + 506, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 506, + 362 + ], + "score": 1.0, + "content": "Since these scaling factors apply to each vertex, we have to expand s into a matrix using the outer", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 360, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 106, + 360, + 505, + 373 + ], + "score": 1.0, + "content": "product in order to scale both incoming and outgoing edges of each vertex. We can also add self-loops", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 371, + 405, + 383 + ], + "spans": [ + { + "bbox": [ + 106, + 371, + 384, + 383 + ], + "score": 1.0, + "content": "back in, which need to be scaled by s as well. Then, the count matrix", + "type": "text" + }, + { + "bbox": [ + 385, + 371, + 394, + 381 + ], + "score": 0.73, + "content": "\\mathbf { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 394, + 371, + 405, + 383 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 348, + 506, + 383 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 228, + 398, + 382, + 415 + ], + "lines": [ + { + "bbox": [ + 228, + 398, + 382, + 415 + ], + "spans": [ + { + "bbox": [ + 228, + 398, + 382, + 415 + ], + "score": 0.91, + "content": "\\mathbf { C } = \\tilde { \\mathbf { A } } \\odot \\mathbf { s s } ^ { \\mathsf { T } } + \\mathrm { { d i a g } } ( \\mathbf { s } \\odot f _ { 1 } ( \\mathbf { a } \\odot \\mathbf { a } ) )", + "type": "interline_equation", + "image_path": "a8773de135a8cbfd0753c09ba2918aff0ae26c0010d20af34943639f7db57f6b.jpg" + } + ] + } + ], + "index": 20, + "virtual_lines": [ + { + "bbox": [ + 228, + 398, + 382, + 415 + ], + "spans": [], + "index": 20 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 425, + 451, + 437 + ], + "lines": [ + { + "bbox": [ + 106, + 424, + 451, + 439 + ], + "spans": [ + { + "bbox": [ + 106, + 424, + 133, + 439 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 425, + 162, + 438 + ], + "score": 0.7, + "content": "\\mathrm { d i a g ( \\cdot ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 424, + 451, + 439 + ], + "score": 1.0, + "content": "expands a vector into a diagonal matrix with the vector on the diagonal.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21, + "bbox_fs": [ + 106, + 424, + 451, + 439 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 442, + 506, + 489 + ], + "lines": [ + { + "bbox": [ + 106, + 442, + 505, + 454 + ], + "spans": [ + { + "bbox": [ + 106, + 442, + 505, + 454 + ], + "score": 1.0, + "content": "The scaling of self-loops involves a non-obvious detail. Recall that the diagonal that was removed", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 453, + 506, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 179, + 468 + ], + "score": 1.0, + "content": "when going from", + "type": "text" + }, + { + "bbox": [ + 180, + 455, + 189, + 465 + ], + "score": 0.27, + "content": "\\mathbf { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 454, + 201, + 468 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 201, + 453, + 212, + 465 + ], + "score": 0.8, + "content": "\\tilde { \\mathbf { A } }", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 454, + 294, + 468 + ], + "score": 1.0, + "content": "contains the entries", + "type": "text" + }, + { + "bbox": [ + 294, + 454, + 336, + 467 + ], + "score": 0.93, + "content": "f _ { 1 } ( \\mathbf { a } \\odot \\mathbf { a } )", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 454, + 506, + 468 + ], + "score": 1.0, + "content": ". Notice however that we are scaling this", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 466, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 203, + 478 + ], + "score": 1.0, + "content": "diagonal by s and not s", + "type": "text" + }, + { + "bbox": [ + 204, + 467, + 213, + 477 + ], + "score": 0.76, + "content": "\\odot", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 466, + 505, + 478 + ], + "score": 1.0, + "content": "s. This is because the number of inter-object edges scales quadratically", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 476, + 506, + 490 + ], + "spans": [ + { + "bbox": [ + 105, + 476, + 506, + 490 + ], + "score": 1.0, + "content": "with respect to the number of proposals per object, but the number of self-loops only scales linearly.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 442, + 506, + 490 + ] + }, + { + "type": "title", + "bbox": [ + 106, + 504, + 168, + 515 + ], + "lines": [ + { + "bbox": [ + 105, + 502, + 169, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 169, + 516 + ], + "score": 1.0, + "content": "4.3 OUTPUT", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 525, + 504, + 548 + ], + "lines": [ + { + "bbox": [ + 106, + 525, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 106, + 525, + 165, + 538 + ], + "score": 1.0, + "content": "Under a sum,", + "type": "text" + }, + { + "bbox": [ + 165, + 525, + 175, + 536 + ], + "score": 0.7, + "content": "\\mathbf { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 525, + 505, + 538 + ], + "score": 1.0, + "content": "is now equivalent to a complete graph with self-loops that involves all relevant", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 536, + 339, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 536, + 339, + 549 + ], + "score": 1.0, + "content": "objects instead of relevant proposals as originally desired.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5, + "bbox_fs": [ + 106, + 525, + 505, + 549 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 552, + 372, + 567 + ], + "lines": [ + { + "bbox": [ + 104, + 551, + 373, + 568 + ], + "spans": [ + { + "bbox": [ + 104, + 551, + 137, + 568 + ], + "score": 1.0, + "content": "To turn", + "type": "text" + }, + { + "bbox": [ + 138, + 554, + 147, + 563 + ], + "score": 0.58, + "content": "\\mathbf { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 147, + 551, + 198, + 568 + ], + "score": 1.0, + "content": "into a count", + "type": "text" + }, + { + "bbox": [ + 198, + 556, + 203, + 563 + ], + "score": 0.68, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 204, + 551, + 234, + 568 + ], + "score": 1.0, + "content": ", we set", + "type": "text" + }, + { + "bbox": [ + 235, + 552, + 298, + 567 + ], + "score": 0.93, + "content": "\\begin{array} { r } { | E | = \\sum _ { i , j } C _ { i j } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 299, + 551, + 373, + 568 + ], + "score": 1.0, + "content": "as mentioned and", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29, + "bbox_fs": [ + 104, + 551, + 373, + 568 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 270, + 574, + 341, + 590 + ], + "lines": [ + { + "bbox": [ + 270, + 574, + 341, + 590 + ], + "spans": [ + { + "bbox": [ + 270, + 574, + 341, + 590 + ], + "score": 0.92, + "content": "c = | V | = \\sqrt { | E | }", + "type": "interline_equation", + "image_path": "642d05cd0b486f94409c6bd6c12f032c0238a4fd56a467acc8fb930fe3c9000b.jpg" + } + ] + } + ], + "index": 30, + "virtual_lines": [ + { + "bbox": [ + 270, + 574, + 341, + 590 + ], + "spans": [], + "index": 30 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 603, + 505, + 626 + ], + "lines": [ + { + "bbox": [ + 106, + 603, + 505, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 603, + 401, + 615 + ], + "score": 1.0, + "content": "We verified experimentally that when our extreme case assumptions hold,", + "type": "text" + }, + { + "bbox": [ + 401, + 606, + 407, + 613 + ], + "score": 0.74, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 603, + 505, + 615 + ], + "score": 1.0, + "content": "is always an integer and", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 614, + 433, + 627 + ], + "spans": [ + { + "bbox": [ + 106, + 614, + 433, + 627 + ], + "score": 1.0, + "content": "equal to the correct count, regardless of the number of duplicate object proposals.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31.5, + "bbox_fs": [ + 106, + 603, + 505, + 627 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 631, + 505, + 665 + ], + "lines": [ + { + "bbox": [ + 105, + 630, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 505, + 644 + ], + "score": 1.0, + "content": "To avoid issues with scale when the number of objects is large, we turn this single feature into several", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 642, + 504, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 642, + 496, + 654 + ], + "score": 1.0, + "content": "classes, one for each possible number. Since we only used the object proposals with the largest", + "type": "text" + }, + { + "bbox": [ + 497, + 644, + 504, + 652 + ], + "score": 0.73, + "content": "n", + "type": "inline_equation" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 652, + 495, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 221, + 666 + ], + "score": 1.0, + "content": "weights, the predicted count", + "type": "text" + }, + { + "bbox": [ + 221, + 655, + 227, + 663 + ], + "score": 0.72, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 652, + 288, + 666 + ], + "score": 1.0, + "content": "can be at most", + "type": "text" + }, + { + "bbox": [ + 288, + 655, + 295, + 663 + ], + "score": 0.74, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 295, + 652, + 384, + 666 + ], + "score": 1.0, + "content": ". We define the output", + "type": "text" + }, + { + "bbox": [ + 384, + 653, + 470, + 665 + ], + "score": 0.93, + "content": "\\mathbf { o } ^ { \\mathsf { ^ { - } } } = [ o _ { 0 } , o _ { 1 } , \\ldots , o _ { n } ] ^ { \\mathsf { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 652, + 495, + 666 + ], + "score": 1.0, + "content": "to be", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34, + "bbox_fs": [ + 105, + 630, + 505, + 666 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 254, + 672, + 357, + 685 + ], + "lines": [ + { + "bbox": [ + 254, + 672, + 357, + 685 + ], + "spans": [ + { + "bbox": [ + 254, + 672, + 357, + 685 + ], + "score": 0.91, + "content": "o _ { i } = \\operatorname* { m a x } ( 0 , 1 - | c - i | )", + "type": "interline_equation", + "image_path": "ce3db8dd9abdf02d670c56ed54df93933685a0172f09abb3c9f5ab60cc58665b.jpg" + } + ] + } + ], + "index": 36, + "virtual_lines": [ + { + "bbox": [ + 254, + 672, + 357, + 685 + ], + "spans": [], + "index": 36 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 698, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 446, + 711 + ], + "score": 1.0, + "content": "This results in a vector that is 1 at the index of the count and 0 everywhere else when", + "type": "text" + }, + { + "bbox": [ + 446, + 701, + 452, + 709 + ], + "score": 0.77, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "is exactly an", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "integer, and a linear interpolation between the two corresponding one-hot vectors when the count", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 720, + 223, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 223, + 734 + ], + "score": 1.0, + "content": "falls inbetween two integers.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 698, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 82, + 234, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 235, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 235, + 94 + ], + "score": 1.0, + "content": "4.3.1 OUTPUT CONFIDENCE", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 101, + 504, + 135 + ], + "lines": [ + { + "bbox": [ + 106, + 101, + 506, + 114 + ], + "spans": [ + { + "bbox": [ + 106, + 101, + 381, + 114 + ], + "score": 1.0, + "content": "Finally, we might consider a prediction made from values of a and", + "type": "text" + }, + { + "bbox": [ + 382, + 102, + 392, + 112 + ], + "score": 0.5, + "content": "\\mathbf { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 101, + 506, + 114 + ], + "score": 1.0, + "content": "that are either close to 0 or", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 112, + 505, + 125 + ], + "spans": [ + { + "bbox": [ + 105, + 112, + 505, + 125 + ], + "score": 1.0, + "content": "close to 1 to be more reliable – we explicitly handle these after all – than when many values are close", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 124, + 450, + 136 + ], + "spans": [ + { + "bbox": [ + 105, + 124, + 270, + 136 + ], + "score": 1.0, + "content": "to 0.5. To incorporate this idea, we scale", + "type": "text" + }, + { + "bbox": [ + 271, + 126, + 278, + 134 + ], + "score": 0.38, + "content": "\\mathbf { o }", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 124, + 425, + 136 + ], + "score": 1.0, + "content": "by a confidence value in the interval", + "type": "text" + }, + { + "bbox": [ + 426, + 124, + 446, + 136 + ], + "score": 0.55, + "content": "[ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 124, + 450, + 136 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 104, + 140, + 504, + 164 + ], + "lines": [ + { + "bbox": [ + 105, + 140, + 505, + 153 + ], + "spans": [ + { + "bbox": [ + 105, + 140, + 148, + 153 + ], + "score": 1.0, + "content": "We define", + "type": "text" + }, + { + "bbox": [ + 148, + 142, + 160, + 152 + ], + "score": 0.86, + "content": "p _ { \\mathbf { a } }", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 140, + 177, + 153 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 178, + 142, + 191, + 152 + ], + "score": 0.83, + "content": "p _ { \\mathbf { D } }", + "type": "inline_equation" + }, + { + "bbox": [ + 192, + 140, + 505, + 153 + ], + "score": 1.0, + "content": "to be the average distances to 0.5. The choice of 0.5 is not important, because", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 150, + 442, + 164 + ], + "spans": [ + { + "bbox": [ + 105, + 150, + 320, + 164 + ], + "score": 1.0, + "content": "the module can learn to change it by changing where", + "type": "text" + }, + { + "bbox": [ + 320, + 151, + 370, + 164 + ], + "score": 0.93, + "content": "f _ { 6 } ( x ) = 0 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 150, + 388, + 164 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 388, + 151, + 438, + 164 + ], + "score": 0.94, + "content": "f _ { 7 } ( x ) = 0 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 150, + 442, + 164 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "interline_equation", + "bbox": [ + 244, + 168, + 367, + 230 + ], + "lines": [ + { + "bbox": [ + 244, + 168, + 367, + 230 + ], + "spans": [ + { + "bbox": [ + 244, + 168, + 367, + 230 + ], + "score": 0.91, + "content": "\\begin{array} { l } { { \\displaystyle p _ { \\mathbf { a } } = \\frac { 1 } { n } \\sum _ { i } \\left. f _ { 6 } ( a _ { i } ) - 0 . 5 \\right. } } \\\\ { { \\displaystyle p _ { \\mathbf { D } } = \\frac { 1 } { n ^ { 2 } } \\sum _ { i , j } \\left. f _ { 7 } ( D _ { i j } ) - 0 . 5 \\right. } } \\end{array}", + "type": "interline_equation", + "image_path": "07e1cfab90748045f79d879721cbde8d479163716e70cd7fd17c744ddb9ade28.jpg" + } + ] + } + ], + "index": 6.5, + "virtual_lines": [ + { + "bbox": [ + 244, + 168, + 367, + 199.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 244, + 199.0, + 367, + 230.0 + ], + "spans": [], + "index": 7 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 239, + 352, + 250 + ], + "lines": [ + { + "bbox": [ + 105, + 238, + 352, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 352, + 252 + ], + "score": 1.0, + "content": "Then, the output of the component with confidence scaling is", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "interline_equation", + "bbox": [ + 262, + 255, + 349, + 270 + ], + "lines": [ + { + "bbox": [ + 262, + 255, + 349, + 270 + ], + "spans": [ + { + "bbox": [ + 262, + 255, + 349, + 270 + ], + "score": 0.91, + "content": "\\tilde { \\mathbf { o } } = f _ { 8 } ( p _ { \\mathbf { a } } + p _ { \\mathbf { D } } ) \\cdot \\mathbf { o }", + "type": "interline_equation", + "image_path": "53af49ee534a302b9679dcb5bea5e590645d46ffb83dc1cf2115eda86e98d6ae.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 262, + 255, + 349, + 270 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 280, + 505, + 314 + ], + "lines": [ + { + "bbox": [ + 105, + 280, + 505, + 293 + ], + "spans": [ + { + "bbox": [ + 105, + 280, + 505, + 293 + ], + "score": 1.0, + "content": "In summary, we only used diffentiable operations to deduplicate object proposals and obtain a feature", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 291, + 505, + 303 + ], + "spans": [ + { + "bbox": [ + 105, + 291, + 505, + 303 + ], + "score": 1.0, + "content": "vector that represents the predicted count. This allows easy integration into any model with soft", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 302, + 345, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 345, + 316 + ], + "score": 1.0, + "content": "attention, enabling a model to count from an attention map.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11 + }, + { + "type": "title", + "bbox": [ + 108, + 329, + 200, + 342 + ], + "lines": [ + { + "bbox": [ + 104, + 328, + 201, + 344 + ], + "spans": [ + { + "bbox": [ + 104, + 328, + 201, + 344 + ], + "score": 1.0, + "content": "5 EXPERIMENTS", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "title", + "bbox": [ + 107, + 354, + 175, + 365 + ], + "lines": [ + { + "bbox": [ + 105, + 352, + 176, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 176, + 367 + ], + "score": 1.0, + "content": "5.1 TOY TASK", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 374, + 505, + 408 + ], + "lines": [ + { + "bbox": [ + 105, + 374, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 505, + 388 + ], + "score": 1.0, + "content": "First, we design a simple toy task to evaluate counting ability. This dataset is intended to only evaluate", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 386, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 506, + 399 + ], + "score": 1.0, + "content": "the performance of counting; thus, we skip any processing steps that are not directly related such as", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 396, + 448, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 448, + 411 + ], + "score": 1.0, + "content": "the processing of an input image. Samples from this dataset are given in Appendix D", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 413, + 505, + 535 + ], + "lines": [ + { + "bbox": [ + 106, + 414, + 505, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 414, + 314, + 426 + ], + "score": 1.0, + "content": "The classification task is to predict an integer count", + "type": "text" + }, + { + "bbox": [ + 314, + 415, + 320, + 424 + ], + "score": 0.74, + "content": "\\hat { c }", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 414, + 505, + 426 + ], + "score": 1.0, + "content": "of true objects, uniformly drawn from 0 to 10", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 424, + 506, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 506, + 439 + ], + "score": 1.0, + "content": "inclusive, from a set of bounding boxes and the associated attention weights. 10 square bounding", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 434, + 506, + 449 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 201, + 449 + ], + "score": 1.0, + "content": "boxes with side length", + "type": "text" + }, + { + "bbox": [ + 201, + 435, + 241, + 448 + ], + "score": 0.93, + "content": "l \\in ( 0 , 1 \\bar { ] }", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 434, + 471, + 449 + ], + "score": 1.0, + "content": "are placed in a square image with unit side length. The", + "type": "text" + }, + { + "bbox": [ + 472, + 437, + 479, + 446 + ], + "score": 0.5, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 434, + 506, + 449 + ], + "score": 1.0, + "content": "and y", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 447, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 447, + 359, + 459 + ], + "score": 1.0, + "content": "coordinates of their top left corners are uniformly drawn from", + "type": "text" + }, + { + "bbox": [ + 360, + 447, + 406, + 459 + ], + "score": 0.93, + "content": "U ( 0 , 1 - l )", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 447, + 506, + 459 + ], + "score": 1.0, + "content": "so that the boxes do not", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 457, + 504, + 470 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 241, + 470 + ], + "score": 1.0, + "content": "extend beyond the image border.", + "type": "text" + }, + { + "bbox": [ + 242, + 458, + 246, + 468 + ], + "score": 0.52, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 247, + 457, + 499, + 470 + ], + "score": 1.0, + "content": "is used to control the overlapping of bounding boxes: a larger", + "type": "text" + }, + { + "bbox": [ + 499, + 458, + 504, + 468 + ], + "score": 0.61, + "content": "l", + "type": "inline_equation" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 468, + 505, + 481 + ], + "spans": [ + { + "bbox": [ + 104, + 468, + 498, + 481 + ], + "score": 1.0, + "content": "leads to the fixed number of objects to be more tightly packed, increasing the chance of overlaps.", + "type": "text" + }, + { + "bbox": [ + 498, + 469, + 505, + 479 + ], + "score": 0.46, + "content": "\\hat { c }", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 479, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 505, + 492 + ], + "score": 1.0, + "content": "number of these boxes are randomly chosen to be true bounding boxes. The score of a bounding box", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 490, + 506, + 503 + ], + "spans": [ + { + "bbox": [ + 105, + 490, + 506, + 503 + ], + "score": 1.0, + "content": "is the maximum IoU overlap of it with any true bounding box. Then, the attention weight is a linear", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 501, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 106, + 502, + 349, + 514 + ], + "score": 1.0, + "content": "interpolation between the score and a noise value drawn from", + "type": "text" + }, + { + "bbox": [ + 349, + 501, + 380, + 514 + ], + "score": 0.92, + "content": "U ( 0 , 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 502, + 403, + 514 + ], + "score": 1.0, + "content": ", with", + "type": "text" + }, + { + "bbox": [ + 404, + 501, + 442, + 513 + ], + "score": 0.92, + "content": "q \\in [ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 442, + 502, + 505, + 514 + ], + "score": 1.0, + "content": "controlling this", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 512, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 145, + 524 + ], + "score": 1.0, + "content": "trade-off.", + "type": "text" + }, + { + "bbox": [ + 146, + 514, + 152, + 524 + ], + "score": 0.77, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 153, + 512, + 304, + 524 + ], + "score": 1.0, + "content": "is the attention noise parameter: when", + "type": "text" + }, + { + "bbox": [ + 304, + 514, + 311, + 524 + ], + "score": 0.79, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 512, + 436, + 524 + ], + "score": 1.0, + "content": "is 0, there is no noise and when", + "type": "text" + }, + { + "bbox": [ + 436, + 514, + 442, + 524 + ], + "score": 0.78, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 443, + 512, + 505, + 524 + ], + "score": 1.0, + "content": "is 1, there is no", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 524, + 454, + 537 + ], + "spans": [ + { + "bbox": [ + 106, + 524, + 180, + 537 + ], + "score": 1.0, + "content": "signal. Increasing", + "type": "text" + }, + { + "bbox": [ + 180, + 525, + 186, + 535 + ], + "score": 0.75, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 524, + 454, + 537 + ], + "score": 1.0, + "content": "also indirectly simulates imprecise placements of bounding boxes.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 540, + 505, + 595 + ], + "lines": [ + { + "bbox": [ + 106, + 541, + 505, + 552 + ], + "spans": [ + { + "bbox": [ + 106, + 541, + 505, + 552 + ], + "score": 1.0, + "content": "We compare the counting component against a simple baseline that simply sums the attention weights", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 551, + 506, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 506, + 564 + ], + "score": 1.0, + "content": "and turns the sum into a feature vector with Equation 8. Both models are followed by a linear", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 561, + 507, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 507, + 576 + ], + "score": 1.0, + "content": "projection to the classes 0 to 10 inclusive and a softmax activation. They are trained with cross-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 573, + 506, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 506, + 586 + ], + "score": 1.0, + "content": "entropy loss for 1000 iterations using Adam (Kingma & Ba, 2015) with a learning rate of 0.01 and a", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 584, + 185, + 596 + ], + "spans": [ + { + "bbox": [ + 106, + 584, + 185, + 596 + ], + "score": 1.0, + "content": "batch size of 1024.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31 + }, + { + "type": "title", + "bbox": [ + 107, + 607, + 179, + 619 + ], + "lines": [ + { + "bbox": [ + 106, + 607, + 180, + 620 + ], + "spans": [ + { + "bbox": [ + 106, + 607, + 180, + 620 + ], + "score": 1.0, + "content": "5.1.1 RESULTS", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 626, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 626, + 507, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 195, + 640 + ], + "score": 1.0, + "content": "The results of varying", + "type": "text" + }, + { + "bbox": [ + 195, + 627, + 200, + 637 + ], + "score": 0.43, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 200, + 626, + 259, + 640 + ], + "score": 1.0, + "content": "while keeping", + "type": "text" + }, + { + "bbox": [ + 259, + 629, + 266, + 639 + ], + "score": 0.75, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 266, + 626, + 507, + 640 + ], + "score": 1.0, + "content": "fixed at various values and vice versa are shown in Figure 4.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 163, + 650 + ], + "score": 1.0, + "content": "Regardless of", + "type": "text" + }, + { + "bbox": [ + 163, + 639, + 167, + 648 + ], + "score": 0.64, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 638, + 185, + 650 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 185, + 640, + 191, + 649 + ], + "score": 0.78, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 192, + 638, + 505, + 650 + ], + "score": 1.0, + "content": ", the counting component performs better than the baseline in most cases, often", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 649, + 505, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 505, + 660 + ], + "score": 1.0, + "content": "significantly so. Particularly when the noise is low, the component can deal with high values for", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 107, + 659, + 505, + 674 + ], + "spans": [ + { + "bbox": [ + 107, + 660, + 111, + 670 + ], + "score": 0.65, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 111, + 659, + 505, + 674 + ], + "score": 1.0, + "content": "very successfully, showing that it accomplishes the goal of increased robustness to overlapping", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 670, + 506, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 506, + 684 + ], + "score": 1.0, + "content": "proposals. The component also handles moderate noise levels decently as long as the overlaps are", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 681, + 505, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 252, + 695 + ], + "score": 1.0, + "content": "limited. The performance when both", + "type": "text" + }, + { + "bbox": [ + 253, + 682, + 257, + 691 + ], + "score": 0.66, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 681, + 274, + 695 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 275, + 683, + 281, + 693 + ], + "score": 0.8, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 281, + 681, + 505, + 695 + ], + "score": 1.0, + "content": "are high is closely matched by the baseline, likely due to", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 693, + 493, + 705 + ], + "spans": [ + { + "bbox": [ + 106, + 693, + 493, + 705 + ], + "score": 1.0, + "content": "the high difficulty of those parametrizations leaving little information to extract in the first place.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 506, + 723 + ], + "score": 1.0, + "content": "We can also look at the shape of the activation functions themselves, shown in Figure 5 and Ap-", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "pendix C, to understand how the behaviour changes with varying dataset parameters. For simplicity,", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 82, + 234, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 235, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 235, + 94 + ], + "score": 1.0, + "content": "4.3.1 OUTPUT CONFIDENCE", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 101, + 504, + 135 + ], + "lines": [ + { + "bbox": [ + 106, + 101, + 506, + 114 + ], + "spans": [ + { + "bbox": [ + 106, + 101, + 381, + 114 + ], + "score": 1.0, + "content": "Finally, we might consider a prediction made from values of a and", + "type": "text" + }, + { + "bbox": [ + 382, + 102, + 392, + 112 + ], + "score": 0.5, + "content": "\\mathbf { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 101, + 506, + 114 + ], + "score": 1.0, + "content": "that are either close to 0 or", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 112, + 505, + 125 + ], + "spans": [ + { + "bbox": [ + 105, + 112, + 505, + 125 + ], + "score": 1.0, + "content": "close to 1 to be more reliable – we explicitly handle these after all – than when many values are close", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 124, + 450, + 136 + ], + "spans": [ + { + "bbox": [ + 105, + 124, + 270, + 136 + ], + "score": 1.0, + "content": "to 0.5. To incorporate this idea, we scale", + "type": "text" + }, + { + "bbox": [ + 271, + 126, + 278, + 134 + ], + "score": 0.38, + "content": "\\mathbf { o }", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 124, + 425, + 136 + ], + "score": 1.0, + "content": "by a confidence value in the interval", + "type": "text" + }, + { + "bbox": [ + 426, + 124, + 446, + 136 + ], + "score": 0.55, + "content": "[ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 124, + 450, + 136 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2, + "bbox_fs": [ + 105, + 101, + 506, + 136 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 140, + 504, + 164 + ], + "lines": [ + { + "bbox": [ + 105, + 140, + 505, + 153 + ], + "spans": [ + { + "bbox": [ + 105, + 140, + 148, + 153 + ], + "score": 1.0, + "content": "We define", + "type": "text" + }, + { + "bbox": [ + 148, + 142, + 160, + 152 + ], + "score": 0.86, + "content": "p _ { \\mathbf { a } }", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 140, + 177, + 153 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 178, + 142, + 191, + 152 + ], + "score": 0.83, + "content": "p _ { \\mathbf { D } }", + "type": "inline_equation" + }, + { + "bbox": [ + 192, + 140, + 505, + 153 + ], + "score": 1.0, + "content": "to be the average distances to 0.5. The choice of 0.5 is not important, because", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 150, + 442, + 164 + ], + "spans": [ + { + "bbox": [ + 105, + 150, + 320, + 164 + ], + "score": 1.0, + "content": "the module can learn to change it by changing where", + "type": "text" + }, + { + "bbox": [ + 320, + 151, + 370, + 164 + ], + "score": 0.93, + "content": "f _ { 6 } ( x ) = 0 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 150, + 388, + 164 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 388, + 151, + 438, + 164 + ], + "score": 0.94, + "content": "f _ { 7 } ( x ) = 0 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 150, + 442, + 164 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5, + "bbox_fs": [ + 105, + 140, + 505, + 164 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 244, + 168, + 367, + 230 + ], + "lines": [ + { + "bbox": [ + 244, + 168, + 367, + 230 + ], + "spans": [ + { + "bbox": [ + 244, + 168, + 367, + 230 + ], + "score": 0.91, + "content": "\\begin{array} { l } { { \\displaystyle p _ { \\mathbf { a } } = \\frac { 1 } { n } \\sum _ { i } \\left. f _ { 6 } ( a _ { i } ) - 0 . 5 \\right. } } \\\\ { { \\displaystyle p _ { \\mathbf { D } } = \\frac { 1 } { n ^ { 2 } } \\sum _ { i , j } \\left. f _ { 7 } ( D _ { i j } ) - 0 . 5 \\right. } } \\end{array}", + "type": "interline_equation", + "image_path": "07e1cfab90748045f79d879721cbde8d479163716e70cd7fd17c744ddb9ade28.jpg" + } + ] + } + ], + "index": 6.5, + "virtual_lines": [ + { + "bbox": [ + 244, + 168, + 367, + 199.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 244, + 199.0, + 367, + 230.0 + ], + "spans": [], + "index": 7 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 239, + 352, + 250 + ], + "lines": [ + { + "bbox": [ + 105, + 238, + 352, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 352, + 252 + ], + "score": 1.0, + "content": "Then, the output of the component with confidence scaling is", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 238, + 352, + 252 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 262, + 255, + 349, + 270 + ], + "lines": [ + { + "bbox": [ + 262, + 255, + 349, + 270 + ], + "spans": [ + { + "bbox": [ + 262, + 255, + 349, + 270 + ], + "score": 0.91, + "content": "\\tilde { \\mathbf { o } } = f _ { 8 } ( p _ { \\mathbf { a } } + p _ { \\mathbf { D } } ) \\cdot \\mathbf { o }", + "type": "interline_equation", + "image_path": "53af49ee534a302b9679dcb5bea5e590645d46ffb83dc1cf2115eda86e98d6ae.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 262, + 255, + 349, + 270 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 280, + 505, + 314 + ], + "lines": [ + { + "bbox": [ + 105, + 280, + 505, + 293 + ], + "spans": [ + { + "bbox": [ + 105, + 280, + 505, + 293 + ], + "score": 1.0, + "content": "In summary, we only used diffentiable operations to deduplicate object proposals and obtain a feature", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 291, + 505, + 303 + ], + "spans": [ + { + "bbox": [ + 105, + 291, + 505, + 303 + ], + "score": 1.0, + "content": "vector that represents the predicted count. This allows easy integration into any model with soft", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 302, + 345, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 345, + 316 + ], + "score": 1.0, + "content": "attention, enabling a model to count from an attention map.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11, + "bbox_fs": [ + 105, + 280, + 505, + 316 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 329, + 200, + 342 + ], + "lines": [ + { + "bbox": [ + 104, + 328, + 201, + 344 + ], + "spans": [ + { + "bbox": [ + 104, + 328, + 201, + 344 + ], + "score": 1.0, + "content": "5 EXPERIMENTS", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "title", + "bbox": [ + 107, + 354, + 175, + 365 + ], + "lines": [ + { + "bbox": [ + 105, + 352, + 176, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 176, + 367 + ], + "score": 1.0, + "content": "5.1 TOY TASK", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 374, + 505, + 408 + ], + "lines": [ + { + "bbox": [ + 105, + 374, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 505, + 388 + ], + "score": 1.0, + "content": "First, we design a simple toy task to evaluate counting ability. This dataset is intended to only evaluate", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 386, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 506, + 399 + ], + "score": 1.0, + "content": "the performance of counting; thus, we skip any processing steps that are not directly related such as", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 396, + 448, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 448, + 411 + ], + "score": 1.0, + "content": "the processing of an input image. Samples from this dataset are given in Appendix D", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16, + "bbox_fs": [ + 105, + 374, + 506, + 411 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 413, + 505, + 535 + ], + "lines": [ + { + "bbox": [ + 106, + 414, + 505, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 414, + 314, + 426 + ], + "score": 1.0, + "content": "The classification task is to predict an integer count", + "type": "text" + }, + { + "bbox": [ + 314, + 415, + 320, + 424 + ], + "score": 0.74, + "content": "\\hat { c }", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 414, + 505, + 426 + ], + "score": 1.0, + "content": "of true objects, uniformly drawn from 0 to 10", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 424, + 506, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 506, + 439 + ], + "score": 1.0, + "content": "inclusive, from a set of bounding boxes and the associated attention weights. 10 square bounding", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 434, + 506, + 449 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 201, + 449 + ], + "score": 1.0, + "content": "boxes with side length", + "type": "text" + }, + { + "bbox": [ + 201, + 435, + 241, + 448 + ], + "score": 0.93, + "content": "l \\in ( 0 , 1 \\bar { ] }", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 434, + 471, + 449 + ], + "score": 1.0, + "content": "are placed in a square image with unit side length. The", + "type": "text" + }, + { + "bbox": [ + 472, + 437, + 479, + 446 + ], + "score": 0.5, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 434, + 506, + 449 + ], + "score": 1.0, + "content": "and y", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 447, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 447, + 359, + 459 + ], + "score": 1.0, + "content": "coordinates of their top left corners are uniformly drawn from", + "type": "text" + }, + { + "bbox": [ + 360, + 447, + 406, + 459 + ], + "score": 0.93, + "content": "U ( 0 , 1 - l )", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 447, + 506, + 459 + ], + "score": 1.0, + "content": "so that the boxes do not", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 457, + 504, + 470 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 241, + 470 + ], + "score": 1.0, + "content": "extend beyond the image border.", + "type": "text" + }, + { + "bbox": [ + 242, + 458, + 246, + 468 + ], + "score": 0.52, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 247, + 457, + 499, + 470 + ], + "score": 1.0, + "content": "is used to control the overlapping of bounding boxes: a larger", + "type": "text" + }, + { + "bbox": [ + 499, + 458, + 504, + 468 + ], + "score": 0.61, + "content": "l", + "type": "inline_equation" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 468, + 505, + 481 + ], + "spans": [ + { + "bbox": [ + 104, + 468, + 498, + 481 + ], + "score": 1.0, + "content": "leads to the fixed number of objects to be more tightly packed, increasing the chance of overlaps.", + "type": "text" + }, + { + "bbox": [ + 498, + 469, + 505, + 479 + ], + "score": 0.46, + "content": "\\hat { c }", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 479, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 505, + 492 + ], + "score": 1.0, + "content": "number of these boxes are randomly chosen to be true bounding boxes. The score of a bounding box", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 490, + 506, + 503 + ], + "spans": [ + { + "bbox": [ + 105, + 490, + 506, + 503 + ], + "score": 1.0, + "content": "is the maximum IoU overlap of it with any true bounding box. Then, the attention weight is a linear", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 501, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 106, + 502, + 349, + 514 + ], + "score": 1.0, + "content": "interpolation between the score and a noise value drawn from", + "type": "text" + }, + { + "bbox": [ + 349, + 501, + 380, + 514 + ], + "score": 0.92, + "content": "U ( 0 , 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 502, + 403, + 514 + ], + "score": 1.0, + "content": ", with", + "type": "text" + }, + { + "bbox": [ + 404, + 501, + 442, + 513 + ], + "score": 0.92, + "content": "q \\in [ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 442, + 502, + 505, + 514 + ], + "score": 1.0, + "content": "controlling this", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 512, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 145, + 524 + ], + "score": 1.0, + "content": "trade-off.", + "type": "text" + }, + { + "bbox": [ + 146, + 514, + 152, + 524 + ], + "score": 0.77, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 153, + 512, + 304, + 524 + ], + "score": 1.0, + "content": "is the attention noise parameter: when", + "type": "text" + }, + { + "bbox": [ + 304, + 514, + 311, + 524 + ], + "score": 0.79, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 512, + 436, + 524 + ], + "score": 1.0, + "content": "is 0, there is no noise and when", + "type": "text" + }, + { + "bbox": [ + 436, + 514, + 442, + 524 + ], + "score": 0.78, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 443, + 512, + 505, + 524 + ], + "score": 1.0, + "content": "is 1, there is no", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 524, + 454, + 537 + ], + "spans": [ + { + "bbox": [ + 106, + 524, + 180, + 537 + ], + "score": 1.0, + "content": "signal. Increasing", + "type": "text" + }, + { + "bbox": [ + 180, + 525, + 186, + 535 + ], + "score": 0.75, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 524, + 454, + 537 + ], + "score": 1.0, + "content": "also indirectly simulates imprecise placements of bounding boxes.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 23, + "bbox_fs": [ + 104, + 414, + 506, + 537 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 540, + 505, + 595 + ], + "lines": [ + { + "bbox": [ + 106, + 541, + 505, + 552 + ], + "spans": [ + { + "bbox": [ + 106, + 541, + 505, + 552 + ], + "score": 1.0, + "content": "We compare the counting component against a simple baseline that simply sums the attention weights", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 551, + 506, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 506, + 564 + ], + "score": 1.0, + "content": "and turns the sum into a feature vector with Equation 8. Both models are followed by a linear", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 561, + 507, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 507, + 576 + ], + "score": 1.0, + "content": "projection to the classes 0 to 10 inclusive and a softmax activation. They are trained with cross-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 573, + 506, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 506, + 586 + ], + "score": 1.0, + "content": "entropy loss for 1000 iterations using Adam (Kingma & Ba, 2015) with a learning rate of 0.01 and a", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 584, + 185, + 596 + ], + "spans": [ + { + "bbox": [ + 106, + 584, + 185, + 596 + ], + "score": 1.0, + "content": "batch size of 1024.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31, + "bbox_fs": [ + 105, + 541, + 507, + 596 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 607, + 179, + 619 + ], + "lines": [ + { + "bbox": [ + 106, + 607, + 180, + 620 + ], + "spans": [ + { + "bbox": [ + 106, + 607, + 180, + 620 + ], + "score": 1.0, + "content": "5.1.1 RESULTS", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 626, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 626, + 507, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 195, + 640 + ], + "score": 1.0, + "content": "The results of varying", + "type": "text" + }, + { + "bbox": [ + 195, + 627, + 200, + 637 + ], + "score": 0.43, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 200, + 626, + 259, + 640 + ], + "score": 1.0, + "content": "while keeping", + "type": "text" + }, + { + "bbox": [ + 259, + 629, + 266, + 639 + ], + "score": 0.75, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 266, + 626, + 507, + 640 + ], + "score": 1.0, + "content": "fixed at various values and vice versa are shown in Figure 4.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 163, + 650 + ], + "score": 1.0, + "content": "Regardless of", + "type": "text" + }, + { + "bbox": [ + 163, + 639, + 167, + 648 + ], + "score": 0.64, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 638, + 185, + 650 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 185, + 640, + 191, + 649 + ], + "score": 0.78, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 192, + 638, + 505, + 650 + ], + "score": 1.0, + "content": ", the counting component performs better than the baseline in most cases, often", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 649, + 505, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 505, + 660 + ], + "score": 1.0, + "content": "significantly so. Particularly when the noise is low, the component can deal with high values for", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 107, + 659, + 505, + 674 + ], + "spans": [ + { + "bbox": [ + 107, + 660, + 111, + 670 + ], + "score": 0.65, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 111, + 659, + 505, + 674 + ], + "score": 1.0, + "content": "very successfully, showing that it accomplishes the goal of increased robustness to overlapping", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 670, + 506, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 506, + 684 + ], + "score": 1.0, + "content": "proposals. The component also handles moderate noise levels decently as long as the overlaps are", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 681, + 505, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 252, + 695 + ], + "score": 1.0, + "content": "limited. The performance when both", + "type": "text" + }, + { + "bbox": [ + 253, + 682, + 257, + 691 + ], + "score": 0.66, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 681, + 274, + 695 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 275, + 683, + 281, + 693 + ], + "score": 0.8, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 281, + 681, + 505, + 695 + ], + "score": 1.0, + "content": "are high is closely matched by the baseline, likely due to", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 693, + 493, + 705 + ], + "spans": [ + { + "bbox": [ + 106, + 693, + 493, + 705 + ], + "score": 1.0, + "content": "the high difficulty of those parametrizations leaving little information to extract in the first place.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 626, + 507, + 705 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 506, + 723 + ], + "score": 1.0, + "content": "We can also look at the shape of the activation functions themselves, shown in Figure 5 and Ap-", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "pendix C, to understand how the behaviour changes with varying dataset parameters. For simplicity,", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 104, + 379, + 504, + 393 + ], + "spans": [ + { + "bbox": [ + 104, + 379, + 365, + 393 + ], + "score": 1.0, + "content": "we limit our description to the two easiest-to-interpret functions:", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 366, + 380, + 376, + 392 + ], + "score": 0.88, + "content": "f _ { 1 }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 376, + 379, + 493, + 393 + ], + "score": 1.0, + "content": "for the attention weights and", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 493, + 380, + 504, + 392 + ], + "score": 0.86, + "content": "f _ { 2 }", + "type": "inline_equation", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 390, + 235, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 235, + 403 + ], + "score": 1.0, + "content": "for the bounding box distances.", + "type": "text", + "cross_page": true + } + ], + "index": 11 + } + ], + "index": 42.5, + "bbox_fs": [ + 105, + 708, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 109, + 79, + 498, + 184 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 79, + 498, + 184 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 79, + 498, + 184 + ], + "spans": [ + { + "bbox": [ + 109, + 79, + 498, + 184 + ], + "score": 0.966, + "type": "image", + "image_path": "3fb48560d3ebed9fd32e0c830572ff36757f872f81d3938700678967ef165a4e.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 109, + 79, + 498, + 114.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 109, + 114.0, + 498, + 149.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 109, + 149.0, + 498, + 184.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 117, + 195, + 491, + 207 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 118, + 194, + 492, + 208 + ], + "spans": [ + { + "bbox": [ + 118, + 194, + 323, + 208 + ], + "score": 1.0, + "content": "Figure 4: Accuracies on the toy task as side length", + "type": "text" + }, + { + "bbox": [ + 323, + 195, + 328, + 205 + ], + "score": 0.56, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 328, + 194, + 369, + 208 + ], + "score": 1.0, + "content": "and noise", + "type": "text" + }, + { + "bbox": [ + 370, + 197, + 376, + 207 + ], + "score": 0.79, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 194, + 492, + 208 + ], + "score": 1.0, + "content": "are varied in 0.01 step sizes.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "image", + "bbox": [ + 108, + 222, + 494, + 313 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 222, + 494, + 313 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 108, + 222, + 494, + 313 + ], + "spans": [ + { + "bbox": [ + 108, + 222, + 494, + 313 + ], + "score": 0.962, + "type": "image", + "image_path": "21e53377d411fcb31ec0d56dc4ccce342dbc7c34ca06a323a7b0659898b842de.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 108, + 222, + 494, + 252.33333333333334 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 108, + 252.33333333333334, + 494, + 282.6666666666667 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 108, + 282.6666666666667, + 494, + 313.0 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 324, + 505, + 357 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 323, + 505, + 336 + ], + "spans": [ + { + "bbox": [ + 105, + 323, + 316, + 336 + ], + "score": 1.0, + "content": "Figure 5: Shapes of trained activation functions", + "type": "text" + }, + { + "bbox": [ + 317, + 324, + 327, + 335 + ], + "score": 0.88, + "content": "f _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 327, + 323, + 429, + 336 + ], + "score": 1.0, + "content": "(attention weights) and", + "type": "text" + }, + { + "bbox": [ + 429, + 324, + 440, + 335 + ], + "score": 0.87, + "content": "f _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 440, + 323, + 505, + 336 + ], + "score": 1.0, + "content": "(bounding box", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 335, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 106, + 335, + 505, + 347 + ], + "score": 1.0, + "content": "distances) for varying bounding box side lengths (left) or the noise (right) in the dataset, varied in", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 346, + 256, + 357 + ], + "spans": [ + { + "bbox": [ + 106, + 346, + 256, + 357 + ], + "score": 1.0, + "content": "0.01 step sizes. Best viewed in color.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 106, + 380, + 504, + 402 + ], + "lines": [ + { + "bbox": [ + 104, + 379, + 504, + 393 + ], + "spans": [ + { + "bbox": [ + 104, + 379, + 365, + 393 + ], + "score": 1.0, + "content": "we limit our description to the two easiest-to-interpret functions:", + "type": "text" + }, + { + "bbox": [ + 366, + 380, + 376, + 392 + ], + "score": 0.88, + "content": "f _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 379, + 493, + 393 + ], + "score": 1.0, + "content": "for the attention weights and", + "type": "text" + }, + { + "bbox": [ + 493, + 380, + 504, + 392 + ], + "score": 0.86, + "content": "f _ { 2 }", + "type": "inline_equation" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 390, + 235, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 235, + 403 + ], + "score": 1.0, + "content": "for the bounding box distances.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 106, + 407, + 505, + 473 + ], + "lines": [ + { + "bbox": [ + 106, + 407, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 407, + 357, + 420 + ], + "score": 1.0, + "content": "When increasing the side length, the height of the “step” in", + "type": "text" + }, + { + "bbox": [ + 357, + 408, + 368, + 419 + ], + "score": 0.87, + "content": "f _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 407, + 505, + 420 + ], + "score": 1.0, + "content": "decreases to compensate for the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 418, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 418, + 455, + 432 + ], + "score": 1.0, + "content": "generally greater degree of overlapping bounding boxes. A similar effect is seen with", + "type": "text" + }, + { + "bbox": [ + 455, + 419, + 466, + 430 + ], + "score": 0.88, + "content": "f _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 418, + 506, + 432 + ], + "score": 1.0, + "content": ": it varies", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 430, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 284, + 442 + ], + "score": 1.0, + "content": "over requiring a high pairwise distance when", + "type": "text" + }, + { + "bbox": [ + 284, + 430, + 289, + 439 + ], + "score": 0.66, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 430, + 506, + 442 + ], + "score": 1.0, + "content": "is low – when partial overlaps are most likely spurious", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 440, + 506, + 453 + ], + "spans": [ + { + "bbox": [ + 104, + 440, + 468, + 453 + ], + "score": 1.0, + "content": "– and considering small distances enough for proposals to be considered different when", + "type": "text" + }, + { + "bbox": [ + 468, + 441, + 473, + 450 + ], + "score": 0.52, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 440, + 506, + 453 + ], + "score": 1.0, + "content": "is high.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 451, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 209, + 464 + ], + "score": 1.0, + "content": "At the highest values for", + "type": "text" + }, + { + "bbox": [ + 209, + 452, + 214, + 462 + ], + "score": 0.33, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 451, + 505, + 464 + ], + "score": 1.0, + "content": ", there is little signal in the overlaps left since everything overlaps with", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 462, + 495, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 235, + 475 + ], + "score": 1.0, + "content": "everything, which explains why", + "type": "text" + }, + { + "bbox": [ + 236, + 463, + 246, + 474 + ], + "score": 0.88, + "content": "f _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 462, + 495, + 475 + ], + "score": 1.0, + "content": "returns to its default linear initialization for those parameters.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14.5 + }, + { + "type": "text", + "bbox": [ + 106, + 479, + 505, + 567 + ], + "lines": [ + { + "bbox": [ + 105, + 478, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 306, + 491 + ], + "score": 1.0, + "content": "When varying the amount of noise, without noise", + "type": "text" + }, + { + "bbox": [ + 306, + 479, + 316, + 491 + ], + "score": 0.89, + "content": "f _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 478, + 505, + 491 + ], + "score": 1.0, + "content": "resembles a step function where the step starts", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 491, + 506, + 503 + ], + "spans": [ + { + "bbox": [ + 106, + 491, + 139, + 503 + ], + "score": 1.0, + "content": "close to", + "type": "text" + }, + { + "bbox": [ + 140, + 491, + 165, + 500 + ], + "score": 0.9, + "content": "x = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 491, + 506, + 503 + ], + "score": 1.0, + "content": "and takes a value of close to 1 after the step. Since a true proposal will always have a", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 500, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 505, + 515 + ], + "score": 1.0, + "content": "weight of 1 when there is no noise, anything below this can be safely zeroed out. With increasing", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 281, + 525 + ], + "score": 1.0, + "content": "noise, this step moves away from 1 for both", + "type": "text" + }, + { + "bbox": [ + 281, + 514, + 288, + 522 + ], + "score": 0.76, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 512, + 306, + 525 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 306, + 512, + 330, + 524 + ], + "score": 0.92, + "content": "f _ { 1 } ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 512, + 505, + 525 + ], + "score": 1.0, + "content": ", capturing the uncertainty when a bounding", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 523, + 507, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 271, + 536 + ], + "score": 1.0, + "content": "box belongs to a true object. With lower", + "type": "text" + }, + { + "bbox": [ + 271, + 525, + 278, + 534 + ], + "score": 0.49, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 523, + 281, + 536 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 281, + 524, + 292, + 535 + ], + "score": 0.71, + "content": "f _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 292, + 523, + 507, + 536 + ], + "score": 1.0, + "content": "considers a pair of proposals to be distinct for lower", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 533, + 506, + 548 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 236, + 548 + ], + "score": 1.0, + "content": "distances, whereas with higher", + "type": "text" + }, + { + "bbox": [ + 237, + 536, + 243, + 546 + ], + "score": 0.34, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 533, + 247, + 548 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 247, + 535, + 258, + 546 + ], + "score": 0.62, + "content": "f _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 533, + 506, + 548 + ], + "score": 1.0, + "content": "follows a more sigmoidal shape. This can be explained by", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 545, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 545, + 505, + 558 + ], + "score": 1.0, + "content": "the model taking the increased uncertainty of the precise bounding box placements into account by", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 556, + 421, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 421, + 568 + ], + "score": 1.0, + "content": "requiring higher distances for proposals to be considered completely different.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 21.5 + }, + { + "type": "title", + "bbox": [ + 107, + 583, + 154, + 595 + ], + "lines": [ + { + "bbox": [ + 104, + 581, + 157, + 598 + ], + "spans": [ + { + "bbox": [ + 104, + 581, + 157, + 598 + ], + "score": 1.0, + "content": "5.2 VQA", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 604, + 505, + 671 + ], + "lines": [ + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "score": 1.0, + "content": "VQA v2 (Goyal et al., 2017) is the updated version of the VQA v1 dataset (Antol et al., 2015) where", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 615, + 506, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 506, + 630 + ], + "score": 1.0, + "content": "greater care has been taken to reduce dataset biases through balanced pairs: for each question, a pair", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "of images is identified where the answer to that question differs. The standard accuracy metric on", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 636, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 392, + 651 + ], + "score": 1.0, + "content": "this dataset accounts for disagreements in human answers by averaging", + "type": "text" + }, + { + "bbox": [ + 393, + 637, + 421, + 651 + ], + "score": 0.36, + "content": "\\mathrm { m i n } ( \\textstyle { \\frac { 1 } { 3 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 421, + 636, + 506, + 651 + ], + "score": 1.0, + "content": "agreeing, 1) over all", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "10-choose-9 subsets of human answers, where agreeing is the number of human answers that agree", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 658, + 496, + 674 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 332, + 674 + ], + "score": 1.0, + "content": "with the given answer. This can be shown to be equal to", + "type": "text" + }, + { + "bbox": [ + 332, + 660, + 416, + 672 + ], + "score": 0.38, + "content": "\\operatorname* { m i n } ( 0 . 3 a g r e e i n g , 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 416, + 658, + 496, + 674 + ], + "score": 1.0, + "content": "without averaging.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 676, + 505, + 689 + ], + "score": 1.0, + "content": "We use an improved version of the strong VQA baseline by Kazemi & Elqursh (2017) as baseline", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 687, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 701 + ], + "score": 1.0, + "content": "model (details in Appendix B). We have not performed any tuning of this baseline to maximize the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "performance difference between it and the baseline with counting module. To augment this model", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "with the counting component, we extract the attention weights of the first attention glimpse (there are", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "two in the baseline) before softmax normalization, and feed them into the counting component after", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 761 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 761 + ], + "score": 1.0, + "content": "8", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 109, + 79, + 498, + 184 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 79, + 498, + 184 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 79, + 498, + 184 + ], + "spans": [ + { + "bbox": [ + 109, + 79, + 498, + 184 + ], + "score": 0.966, + "type": "image", + "image_path": "3fb48560d3ebed9fd32e0c830572ff36757f872f81d3938700678967ef165a4e.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 109, + 79, + 498, + 114.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 109, + 114.0, + 498, + 149.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 109, + 149.0, + 498, + 184.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 117, + 195, + 491, + 207 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 118, + 194, + 492, + 208 + ], + "spans": [ + { + "bbox": [ + 118, + 194, + 323, + 208 + ], + "score": 1.0, + "content": "Figure 4: Accuracies on the toy task as side length", + "type": "text" + }, + { + "bbox": [ + 323, + 195, + 328, + 205 + ], + "score": 0.56, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 328, + 194, + 369, + 208 + ], + "score": 1.0, + "content": "and noise", + "type": "text" + }, + { + "bbox": [ + 370, + 197, + 376, + 207 + ], + "score": 0.79, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 194, + 492, + 208 + ], + "score": 1.0, + "content": "are varied in 0.01 step sizes.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "image", + "bbox": [ + 108, + 222, + 494, + 313 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 222, + 494, + 313 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 108, + 222, + 494, + 313 + ], + "spans": [ + { + "bbox": [ + 108, + 222, + 494, + 313 + ], + "score": 0.962, + "type": "image", + "image_path": "21e53377d411fcb31ec0d56dc4ccce342dbc7c34ca06a323a7b0659898b842de.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 108, + 222, + 494, + 252.33333333333334 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 108, + 252.33333333333334, + 494, + 282.6666666666667 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 108, + 282.6666666666667, + 494, + 313.0 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 324, + 505, + 357 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 323, + 505, + 336 + ], + "spans": [ + { + "bbox": [ + 105, + 323, + 316, + 336 + ], + "score": 1.0, + "content": "Figure 5: Shapes of trained activation functions", + "type": "text" + }, + { + "bbox": [ + 317, + 324, + 327, + 335 + ], + "score": 0.88, + "content": "f _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 327, + 323, + 429, + 336 + ], + "score": 1.0, + "content": "(attention weights) and", + "type": "text" + }, + { + "bbox": [ + 429, + 324, + 440, + 335 + ], + "score": 0.87, + "content": "f _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 440, + 323, + 505, + 336 + ], + "score": 1.0, + "content": "(bounding box", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 335, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 106, + 335, + 505, + 347 + ], + "score": 1.0, + "content": "distances) for varying bounding box side lengths (left) or the noise (right) in the dataset, varied in", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 346, + 256, + 357 + ], + "spans": [ + { + "bbox": [ + 106, + 346, + 256, + 357 + ], + "score": 1.0, + "content": "0.01 step sizes. Best viewed in color.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 106, + 380, + 504, + 402 + ], + "lines": [], + "index": 10.5, + "bbox_fs": [ + 104, + 379, + 504, + 403 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 407, + 505, + 473 + ], + "lines": [ + { + "bbox": [ + 106, + 407, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 407, + 357, + 420 + ], + "score": 1.0, + "content": "When increasing the side length, the height of the “step” in", + "type": "text" + }, + { + "bbox": [ + 357, + 408, + 368, + 419 + ], + "score": 0.87, + "content": "f _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 407, + 505, + 420 + ], + "score": 1.0, + "content": "decreases to compensate for the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 418, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 418, + 455, + 432 + ], + "score": 1.0, + "content": "generally greater degree of overlapping bounding boxes. A similar effect is seen with", + "type": "text" + }, + { + "bbox": [ + 455, + 419, + 466, + 430 + ], + "score": 0.88, + "content": "f _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 418, + 506, + 432 + ], + "score": 1.0, + "content": ": it varies", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 430, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 284, + 442 + ], + "score": 1.0, + "content": "over requiring a high pairwise distance when", + "type": "text" + }, + { + "bbox": [ + 284, + 430, + 289, + 439 + ], + "score": 0.66, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 430, + 506, + 442 + ], + "score": 1.0, + "content": "is low – when partial overlaps are most likely spurious", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 440, + 506, + 453 + ], + "spans": [ + { + "bbox": [ + 104, + 440, + 468, + 453 + ], + "score": 1.0, + "content": "– and considering small distances enough for proposals to be considered different when", + "type": "text" + }, + { + "bbox": [ + 468, + 441, + 473, + 450 + ], + "score": 0.52, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 440, + 506, + 453 + ], + "score": 1.0, + "content": "is high.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 451, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 209, + 464 + ], + "score": 1.0, + "content": "At the highest values for", + "type": "text" + }, + { + "bbox": [ + 209, + 452, + 214, + 462 + ], + "score": 0.33, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 451, + 505, + 464 + ], + "score": 1.0, + "content": ", there is little signal in the overlaps left since everything overlaps with", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 462, + 495, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 235, + 475 + ], + "score": 1.0, + "content": "everything, which explains why", + "type": "text" + }, + { + "bbox": [ + 236, + 463, + 246, + 474 + ], + "score": 0.88, + "content": "f _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 462, + 495, + 475 + ], + "score": 1.0, + "content": "returns to its default linear initialization for those parameters.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14.5, + "bbox_fs": [ + 104, + 407, + 506, + 475 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 479, + 505, + 567 + ], + "lines": [ + { + "bbox": [ + 105, + 478, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 306, + 491 + ], + "score": 1.0, + "content": "When varying the amount of noise, without noise", + "type": "text" + }, + { + "bbox": [ + 306, + 479, + 316, + 491 + ], + "score": 0.89, + "content": "f _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 478, + 505, + 491 + ], + "score": 1.0, + "content": "resembles a step function where the step starts", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 491, + 506, + 503 + ], + "spans": [ + { + "bbox": [ + 106, + 491, + 139, + 503 + ], + "score": 1.0, + "content": "close to", + "type": "text" + }, + { + "bbox": [ + 140, + 491, + 165, + 500 + ], + "score": 0.9, + "content": "x = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 491, + 506, + 503 + ], + "score": 1.0, + "content": "and takes a value of close to 1 after the step. Since a true proposal will always have a", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 500, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 505, + 515 + ], + "score": 1.0, + "content": "weight of 1 when there is no noise, anything below this can be safely zeroed out. With increasing", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 281, + 525 + ], + "score": 1.0, + "content": "noise, this step moves away from 1 for both", + "type": "text" + }, + { + "bbox": [ + 281, + 514, + 288, + 522 + ], + "score": 0.76, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 512, + 306, + 525 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 306, + 512, + 330, + 524 + ], + "score": 0.92, + "content": "f _ { 1 } ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 512, + 505, + 525 + ], + "score": 1.0, + "content": ", capturing the uncertainty when a bounding", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 523, + 507, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 271, + 536 + ], + "score": 1.0, + "content": "box belongs to a true object. With lower", + "type": "text" + }, + { + "bbox": [ + 271, + 525, + 278, + 534 + ], + "score": 0.49, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 523, + 281, + 536 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 281, + 524, + 292, + 535 + ], + "score": 0.71, + "content": "f _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 292, + 523, + 507, + 536 + ], + "score": 1.0, + "content": "considers a pair of proposals to be distinct for lower", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 533, + 506, + 548 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 236, + 548 + ], + "score": 1.0, + "content": "distances, whereas with higher", + "type": "text" + }, + { + "bbox": [ + 237, + 536, + 243, + 546 + ], + "score": 0.34, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 533, + 247, + 548 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 247, + 535, + 258, + 546 + ], + "score": 0.62, + "content": "f _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 533, + 506, + 548 + ], + "score": 1.0, + "content": "follows a more sigmoidal shape. This can be explained by", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 545, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 545, + 505, + 558 + ], + "score": 1.0, + "content": "the model taking the increased uncertainty of the precise bounding box placements into account by", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 556, + 421, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 421, + 568 + ], + "score": 1.0, + "content": "requiring higher distances for proposals to be considered completely different.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 478, + 507, + 568 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 583, + 154, + 595 + ], + "lines": [ + { + "bbox": [ + 104, + 581, + 157, + 598 + ], + "spans": [ + { + "bbox": [ + 104, + 581, + 157, + 598 + ], + "score": 1.0, + "content": "5.2 VQA", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 604, + 505, + 671 + ], + "lines": [ + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "score": 1.0, + "content": "VQA v2 (Goyal et al., 2017) is the updated version of the VQA v1 dataset (Antol et al., 2015) where", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 615, + 506, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 506, + 630 + ], + "score": 1.0, + "content": "greater care has been taken to reduce dataset biases through balanced pairs: for each question, a pair", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "of images is identified where the answer to that question differs. The standard accuracy metric on", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 636, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 392, + 651 + ], + "score": 1.0, + "content": "this dataset accounts for disagreements in human answers by averaging", + "type": "text" + }, + { + "bbox": [ + 393, + 637, + 421, + 651 + ], + "score": 0.36, + "content": "\\mathrm { m i n } ( \\textstyle { \\frac { 1 } { 3 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 421, + 636, + 506, + 651 + ], + "score": 1.0, + "content": "agreeing, 1) over all", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "10-choose-9 subsets of human answers, where agreeing is the number of human answers that agree", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 658, + 496, + 674 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 332, + 674 + ], + "score": 1.0, + "content": "with the given answer. This can be shown to be equal to", + "type": "text" + }, + { + "bbox": [ + 332, + 660, + 416, + 672 + ], + "score": 0.38, + "content": "\\operatorname* { m i n } ( 0 . 3 a g r e e i n g , 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 416, + 658, + 496, + 674 + ], + "score": 1.0, + "content": "without averaging.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 29.5, + "bbox_fs": [ + 105, + 604, + 506, + 674 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 676, + 505, + 689 + ], + "score": 1.0, + "content": "We use an improved version of the strong VQA baseline by Kazemi & Elqursh (2017) as baseline", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 687, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 701 + ], + "score": 1.0, + "content": "model (details in Appendix B). We have not performed any tuning of this baseline to maximize the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "performance difference between it and the baseline with counting module. To augment this model", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "with the counting component, we extract the attention weights of the first attention glimpse (there are", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "two in the baseline) before softmax normalization, and feed them into the counting component after", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 399, + 506, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 506, + 411 + ], + "score": 1.0, + "content": "applying a logistic function. Since object proposal features from Anderson et al. (2017) vary from 10", + "type": "text", + "cross_page": true + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 410, + 506, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 333, + 423 + ], + "score": 1.0, + "content": "to 100 per image, a natural choice for the number of top-", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 334, + 412, + 341, + 420 + ], + "score": 0.72, + "content": "^ n", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 341, + 410, + 506, + 423 + ], + "score": 1.0, + "content": "proposals to use is 10. The output of the", + "type": "text", + "cross_page": true + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 421, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 505, + 434 + ], + "score": 1.0, + "content": "component is linearly projected into the same space as the hidden layer of the classifier, followed by", + "type": "text", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 431, + 461, + 445 + ], + "spans": [ + { + "bbox": [ + 105, + 431, + 461, + 445 + ], + "score": 1.0, + "content": "ReLU activation, batch normalization, and addition with the features in the hidden layer.", + "type": "text", + "cross_page": true + } + ], + "index": 16 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 676, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 109, + 152, + 502, + 254 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 89, + 505, + 145 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 88, + 505, + 101 + ], + "spans": [ + { + "bbox": [ + 105, + 88, + 505, + 101 + ], + "score": 1.0, + "content": "Table 1: Results on VQA v2 of the top models along with our results. Entries marked with (Ens.) are", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 99, + 506, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 506, + 113 + ], + "score": 1.0, + "content": "ensembles of models. At the time of writing, our model with the counting module places third among", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "spans": [ + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "score": 1.0, + "content": "all entries. All models listed here use object proposal features and are trained on the training and", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 120, + 507, + 136 + ], + "spans": [ + { + "bbox": [ + 105, + 120, + 507, + 136 + ], + "score": 1.0, + "content": "validation sets. The top-performing ensemble models use additional pre-trained word embeddings,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 132, + 193, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 193, + 145 + ], + "score": 1.0, + "content": "which we do not use.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2 + }, + { + "type": "table_body", + "bbox": [ + 109, + 152, + 502, + 254 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 152, + 502, + 254 + ], + "spans": [ + { + "bbox": [ + 109, + 152, + 502, + 254 + ], + "score": 0.984, + "html": "
VQA v2 test-devVQA v2 test
ModelYes/NoNumberOtherAllYes/NoNumberOtherAll
Teney et al. (2017)81.8244.2156.0565.3282.2043.9056.2665.67
Teney et al. (2017) (Ens.)86.0848.9960.8069.8786.6048.6461.1570.34
Zhou et al. (2017)84.2749.5659.8968.761111
Zhou et al. (2017) (Ens.)111186.6551.1361.7570.92
Baseline82.9846.8858.9967.5083.2146.6059.2067.78
+ counting module83.1451.6258.9768.0983.5651.3959.1168.41
", + "type": "table", + "image_path": "c12ac0860ac18470491eb64dfeb797a85057704bc04f85b9dc1e0148c4e3864d.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 109, + 152, + 502, + 186.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 109, + 186.0, + 502, + 220.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 109, + 220.0, + 502, + 254.0 + ], + "spans": [], + "index": 7 + } + ] + } + ], + "index": 4.0 + }, + { + "type": "table", + "bbox": [ + 109, + 308, + 502, + 376 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 276, + 505, + 298 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 276, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 106, + 276, + 505, + 288 + ], + "score": 1.0, + "content": "Table 2: Results on the VQA v2 validation set with models trained only on the training set. Reported", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 287, + 466, + 298 + ], + "spans": [ + { + "bbox": [ + 106, + 287, + 331, + 298 + ], + "score": 1.0, + "content": "are the mean accuracies and sample standard deviations", + "type": "text" + }, + { + "bbox": [ + 331, + 287, + 347, + 298 + ], + "score": 0.77, + "content": "( \\pm )", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 287, + 466, + 298 + ], + "score": 1.0, + "content": "over 4 random initializations.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5 + }, + { + "type": "table_body", + "bbox": [ + 109, + 308, + 502, + 376 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 109, + 308, + 502, + 376 + ], + "spans": [ + { + "bbox": [ + 109, + 308, + 502, + 376 + ], + "score": 0.981, + "html": "
VQA accuracyBalanced pair accuracy
ModelNumberCountAllNumberCountAll
Baseline44.83±0.251.69±0.264.80±0.017.34±0.220.02±0.236.44±0.1
+ NMS44.60±0.151.41±0.164.80±0.117.06±0.119.72±0.136.44±0.2
+ counting module49.36±0.157.03±0.065.42±0.123.10±0.226.63±0.237.19±0.1
", + "type": "table", + "image_path": "8a485d8326b1c17cd1b9585e152972b482af0f4769cb7d35c1191a8d47936aef.jpg" + } + ] + } + ], + "index": 11, + "virtual_lines": [ + { + "bbox": [ + 109, + 308, + 502, + 330.6666666666667 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 109, + 330.6666666666667, + 502, + 353.33333333333337 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 109, + 353.33333333333337, + 502, + 376.00000000000006 + ], + "spans": [], + "index": 12 + } + ] + } + ], + "index": 9.75 + }, + { + "type": "text", + "bbox": [ + 107, + 398, + 505, + 443 + ], + "lines": [ + { + "bbox": [ + 105, + 399, + 506, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 506, + 411 + ], + "score": 1.0, + "content": "applying a logistic function. Since object proposal features from Anderson et al. (2017) vary from 10", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 410, + 506, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 333, + 423 + ], + "score": 1.0, + "content": "to 100 per image, a natural choice for the number of top-", + "type": "text" + }, + { + "bbox": [ + 334, + 412, + 341, + 420 + ], + "score": 0.72, + "content": "^ n", + "type": "inline_equation" + }, + { + "bbox": [ + 341, + 410, + 506, + 423 + ], + "score": 1.0, + "content": "proposals to use is 10. The output of the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 421, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 505, + 434 + ], + "score": 1.0, + "content": "component is linearly projected into the same space as the hidden layer of the classifier, followed by", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 431, + 461, + 445 + ], + "spans": [ + { + "bbox": [ + 105, + 431, + 461, + 445 + ], + "score": 1.0, + "content": "ReLU activation, batch normalization, and addition with the features in the hidden layer.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 14.5 + }, + { + "type": "title", + "bbox": [ + 107, + 458, + 178, + 469 + ], + "lines": [ + { + "bbox": [ + 105, + 457, + 180, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 180, + 471 + ], + "score": 1.0, + "content": "5.2.1 RESULTS", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 478, + 505, + 577 + ], + "lines": [ + { + "bbox": [ + 105, + 477, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 506, + 492 + ], + "score": 1.0, + "content": "Table 1 shows the results on the official VQA v2 leaderboard. The baseline with our component", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 489, + 506, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 506, + 502 + ], + "score": 1.0, + "content": "has a significantly higher accuracy on number questions without compromising accuracy on other", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 500, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 505, + 514 + ], + "score": 1.0, + "content": "categories compared to the baseline result. Despite our single-model baseline being substantially", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "score": 1.0, + "content": "worse than the state-of-the-art, by simply adding the counting component we outperform even the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 523, + 506, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 506, + 536 + ], + "score": 1.0, + "content": "8-model ensemble in Zhou et al. (2017) on the number category. We expect further improvements in", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 533, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 506, + 546 + ], + "score": 1.0, + "content": "number accuracy when incorporating their techniques to improve the quality of attention weights,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 544, + 506, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 506, + 557 + ], + "score": 1.0, + "content": "especially since the current state-of-the-art models suffer from the problems with counting that", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 554, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 505, + 569 + ], + "score": 1.0, + "content": "we mention in section 3. Some qualitative examples of inputs and activations within the counting", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 566, + 259, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 259, + 578 + ], + "score": 1.0, + "content": "component are shown in Appendix E.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 583, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 106, + 582, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 582, + 505, + 595 + ], + "score": 1.0, + "content": "We also evaluate our models on the validation set of VQA v2, shown in Table 2. This allows us", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 595, + 504, + 606 + ], + "spans": [ + { + "bbox": [ + 106, + 595, + 504, + 606 + ], + "score": 1.0, + "content": "to consider only the counting questions within number questions, since number questions include", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 604, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 505, + 618 + ], + "score": 1.0, + "content": "questions such as ”what time is it?” as well. We treat any question starting with the words ”how", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 615, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 630 + ], + "score": 1.0, + "content": "many” as a counting question. As we expect, the benefit of using the counting module on the counting", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "score": 1.0, + "content": "question subset is higher than on number questions in general. Additionally, we try an approach", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 638, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 505, + 651 + ], + "score": 1.0, + "content": "where we simply replace the counting module with NMS, using the average of the attention glimpses", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "as scoring, and one-hot encoding the number of proposals left. The NMS-based approach, using an", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 659, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 505, + 673 + ], + "score": 1.0, + "content": "IoU threshold of 0.5 and no score thresholding based on validation set performance, does not improve", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "score": 1.0, + "content": "on the baseline, which suggests that the piecewise gradient of NMS is a major problem for learning to", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 682, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 505, + 694 + ], + "score": 1.0, + "content": "count in VQA and that conversely, there is a substantial benefit to being able to differentiate through", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 693, + 193, + 705 + ], + "spans": [ + { + "bbox": [ + 105, + 693, + 193, + 705 + ], + "score": 1.0, + "content": "the counting module.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "Additionally, we can evaluate the accuracy over balanced pairs as proposed by Teney et al. (2017):", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "the ratio of balanced pairs on which the VQA accuracy for both questions is 1.0. This is a much", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "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": "table", + "bbox": [ + 109, + 152, + 502, + 254 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 89, + 505, + 145 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 88, + 505, + 101 + ], + "spans": [ + { + "bbox": [ + 105, + 88, + 505, + 101 + ], + "score": 1.0, + "content": "Table 1: Results on VQA v2 of the top models along with our results. Entries marked with (Ens.) are", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 99, + 506, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 506, + 113 + ], + "score": 1.0, + "content": "ensembles of models. At the time of writing, our model with the counting module places third among", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "spans": [ + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "score": 1.0, + "content": "all entries. All models listed here use object proposal features and are trained on the training and", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 120, + 507, + 136 + ], + "spans": [ + { + "bbox": [ + 105, + 120, + 507, + 136 + ], + "score": 1.0, + "content": "validation sets. The top-performing ensemble models use additional pre-trained word embeddings,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 132, + 193, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 193, + 145 + ], + "score": 1.0, + "content": "which we do not use.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2 + }, + { + "type": "table_body", + "bbox": [ + 109, + 152, + 502, + 254 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 152, + 502, + 254 + ], + "spans": [ + { + "bbox": [ + 109, + 152, + 502, + 254 + ], + "score": 0.984, + "html": "
VQA v2 test-devVQA v2 test
ModelYes/NoNumberOtherAllYes/NoNumberOtherAll
Teney et al. (2017)81.8244.2156.0565.3282.2043.9056.2665.67
Teney et al. (2017) (Ens.)86.0848.9960.8069.8786.6048.6461.1570.34
Zhou et al. (2017)84.2749.5659.8968.761111
Zhou et al. (2017) (Ens.)111186.6551.1361.7570.92
Baseline82.9846.8858.9967.5083.2146.6059.2067.78
+ counting module83.1451.6258.9768.0983.5651.3959.1168.41
", + "type": "table", + "image_path": "c12ac0860ac18470491eb64dfeb797a85057704bc04f85b9dc1e0148c4e3864d.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 109, + 152, + 502, + 186.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 109, + 186.0, + 502, + 220.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 109, + 220.0, + 502, + 254.0 + ], + "spans": [], + "index": 7 + } + ] + } + ], + "index": 4.0 + }, + { + "type": "table", + "bbox": [ + 109, + 308, + 502, + 376 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 276, + 505, + 298 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 276, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 106, + 276, + 505, + 288 + ], + "score": 1.0, + "content": "Table 2: Results on the VQA v2 validation set with models trained only on the training set. Reported", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 287, + 466, + 298 + ], + "spans": [ + { + "bbox": [ + 106, + 287, + 331, + 298 + ], + "score": 1.0, + "content": "are the mean accuracies and sample standard deviations", + "type": "text" + }, + { + "bbox": [ + 331, + 287, + 347, + 298 + ], + "score": 0.77, + "content": "( \\pm )", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 287, + 466, + 298 + ], + "score": 1.0, + "content": "over 4 random initializations.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5 + }, + { + "type": "table_body", + "bbox": [ + 109, + 308, + 502, + 376 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 109, + 308, + 502, + 376 + ], + "spans": [ + { + "bbox": [ + 109, + 308, + 502, + 376 + ], + "score": 0.981, + "html": "
VQA accuracyBalanced pair accuracy
ModelNumberCountAllNumberCountAll
Baseline44.83±0.251.69±0.264.80±0.017.34±0.220.02±0.236.44±0.1
+ NMS44.60±0.151.41±0.164.80±0.117.06±0.119.72±0.136.44±0.2
+ counting module49.36±0.157.03±0.065.42±0.123.10±0.226.63±0.237.19±0.1
", + "type": "table", + "image_path": "8a485d8326b1c17cd1b9585e152972b482af0f4769cb7d35c1191a8d47936aef.jpg" + } + ] + } + ], + "index": 11, + "virtual_lines": [ + { + "bbox": [ + 109, + 308, + 502, + 330.6666666666667 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 109, + 330.6666666666667, + 502, + 353.33333333333337 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 109, + 353.33333333333337, + 502, + 376.00000000000006 + ], + "spans": [], + "index": 12 + } + ] + } + ], + "index": 9.75 + }, + { + "type": "text", + "bbox": [ + 107, + 398, + 505, + 443 + ], + "lines": [], + "index": 14.5, + "bbox_fs": [ + 105, + 399, + 506, + 445 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 107, + 458, + 178, + 469 + ], + "lines": [ + { + "bbox": [ + 105, + 457, + 180, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 180, + 471 + ], + "score": 1.0, + "content": "5.2.1 RESULTS", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 478, + 505, + 577 + ], + "lines": [ + { + "bbox": [ + 105, + 477, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 506, + 492 + ], + "score": 1.0, + "content": "Table 1 shows the results on the official VQA v2 leaderboard. The baseline with our component", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 489, + 506, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 506, + 502 + ], + "score": 1.0, + "content": "has a significantly higher accuracy on number questions without compromising accuracy on other", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 500, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 505, + 514 + ], + "score": 1.0, + "content": "categories compared to the baseline result. Despite our single-model baseline being substantially", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "score": 1.0, + "content": "worse than the state-of-the-art, by simply adding the counting component we outperform even the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 523, + 506, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 506, + 536 + ], + "score": 1.0, + "content": "8-model ensemble in Zhou et al. (2017) on the number category. We expect further improvements in", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 533, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 506, + 546 + ], + "score": 1.0, + "content": "number accuracy when incorporating their techniques to improve the quality of attention weights,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 544, + 506, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 506, + 557 + ], + "score": 1.0, + "content": "especially since the current state-of-the-art models suffer from the problems with counting that", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 554, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 505, + 569 + ], + "score": 1.0, + "content": "we mention in section 3. Some qualitative examples of inputs and activations within the counting", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 566, + 259, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 259, + 578 + ], + "score": 1.0, + "content": "component are shown in Appendix E.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 22, + "bbox_fs": [ + 105, + 477, + 506, + 578 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 583, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 106, + 582, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 582, + 505, + 595 + ], + "score": 1.0, + "content": "We also evaluate our models on the validation set of VQA v2, shown in Table 2. This allows us", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 595, + 504, + 606 + ], + "spans": [ + { + "bbox": [ + 106, + 595, + 504, + 606 + ], + "score": 1.0, + "content": "to consider only the counting questions within number questions, since number questions include", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 604, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 505, + 618 + ], + "score": 1.0, + "content": "questions such as ”what time is it?” as well. We treat any question starting with the words ”how", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 615, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 630 + ], + "score": 1.0, + "content": "many” as a counting question. As we expect, the benefit of using the counting module on the counting", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "score": 1.0, + "content": "question subset is higher than on number questions in general. Additionally, we try an approach", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 638, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 505, + 651 + ], + "score": 1.0, + "content": "where we simply replace the counting module with NMS, using the average of the attention glimpses", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "as scoring, and one-hot encoding the number of proposals left. The NMS-based approach, using an", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 659, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 505, + 673 + ], + "score": 1.0, + "content": "IoU threshold of 0.5 and no score thresholding based on validation set performance, does not improve", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "score": 1.0, + "content": "on the baseline, which suggests that the piecewise gradient of NMS is a major problem for learning to", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 682, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 505, + 694 + ], + "score": 1.0, + "content": "count in VQA and that conversely, there is a substantial benefit to being able to differentiate through", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 693, + 193, + 705 + ], + "spans": [ + { + "bbox": [ + 105, + 693, + 193, + 705 + ], + "score": 1.0, + "content": "the counting module.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 32, + "bbox_fs": [ + 105, + 582, + 505, + 705 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "Additionally, we can evaluate the accuracy over balanced pairs as proposed by Teney et al. (2017):", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "the ratio of balanced pairs on which the VQA accuracy for both questions is 1.0. This is a much", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "score": 1.0, + "content": "more difficult metric, since it requires the model to find the subtle details between images instead of", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "being able to rely on question biases in the dataset. First, notice how all balanced pair accuracies are", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 118 + ], + "score": 1.0, + "content": "greatly reduced compared to their respective VQA accuracy. More importantly, the absolute accuracy", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 115, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 505, + 128 + ], + "score": 1.0, + "content": "improvement of the counting module is still fully present with the more challenging metric, which is", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 104, + 125, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 104, + 125, + 506, + 140 + ], + "score": 1.0, + "content": "further evidence that the component can properly count rather than simply fitting better to dataset", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 136, + 137, + 149 + ], + "spans": [ + { + "bbox": [ + 105, + 136, + 137, + 149 + ], + "score": 1.0, + "content": "biases.", + "type": "text", + "cross_page": true + } + ], + "index": 5 + } + ], + "index": 38.5, + "bbox_fs": [ + 105, + 709, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 148 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "score": 1.0, + "content": "more difficult metric, since it requires the model to find the subtle details between images instead of", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "being able to rely on question biases in the dataset. First, notice how all balanced pair accuracies are", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 118 + ], + "score": 1.0, + "content": "greatly reduced compared to their respective VQA accuracy. More importantly, the absolute accuracy", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 115, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 505, + 128 + ], + "score": 1.0, + "content": "improvement of the counting module is still fully present with the more challenging metric, which is", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 104, + 125, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 104, + 125, + 506, + 140 + ], + "score": 1.0, + "content": "further evidence that the component can properly count rather than simply fitting better to dataset", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 136, + 137, + 149 + ], + "spans": [ + { + "bbox": [ + 105, + 136, + 137, + 149 + ], + "score": 1.0, + "content": "biases.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 154, + 505, + 220 + ], + "lines": [ + { + "bbox": [ + 105, + 153, + 506, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 506, + 167 + ], + "score": 1.0, + "content": "When looking at the activation functions of the trained model, shown in Figure 9, we find that some", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 165, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 106, + 165, + 505, + 177 + ], + "score": 1.0, + "content": "characteristics of them are shared with high-noise parametrizations of the toy dataset. This suggests", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "score": 1.0, + "content": "that the current attention mechanisms and object proposal network are still very inaccurate, which", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "score": 1.0, + "content": "explains the perhaps small-seeming increase in counting performance. This provides further evidence", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 505, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 505, + 211 + ], + "score": 1.0, + "content": "that the balanced pair accuracy is maybe a more reflective measure of how well current VQA models", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 209, + 430, + 221 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 303, + 221 + ], + "score": 1.0, + "content": "perform than the overall VQA accuracies of over", + "type": "text" + }, + { + "bbox": [ + 304, + 209, + 324, + 220 + ], + "score": 0.88, + "content": "70 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 209, + 430, + 221 + ], + "score": 1.0, + "content": "of the current top models.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8.5 + }, + { + "type": "title", + "bbox": [ + 107, + 236, + 195, + 249 + ], + "lines": [ + { + "bbox": [ + 105, + 235, + 197, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 197, + 252 + ], + "score": 1.0, + "content": "6 CONCLUSION", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 261, + 505, + 382 + ], + "lines": [ + { + "bbox": [ + 106, + 261, + 506, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 506, + 273 + ], + "score": 1.0, + "content": "After understanding why VQA models struggle to count, we designed a counting component that", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 272, + 505, + 285 + ], + "spans": [ + { + "bbox": [ + 105, + 272, + 505, + 285 + ], + "score": 1.0, + "content": "alleviates this problem through differentiable bounding box deduplication. The component can readily", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 283, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 106, + 283, + 505, + 295 + ], + "score": 1.0, + "content": "be used alongside any future improvements in VQA models, as long as they still use soft attention as", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 293, + 506, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 506, + 307 + ], + "score": 1.0, + "content": "all current top models on VQA v2 do. It has uses outside of VQA as well: for many counting tasks,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 305, + 506, + 317 + ], + "spans": [ + { + "bbox": [ + 105, + 305, + 506, + 317 + ], + "score": 1.0, + "content": "it can allow an object-proposal-based approach to work without ground-truth objects available as", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 315, + 506, + 329 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 506, + 329 + ], + "score": 1.0, + "content": "long as there is a – possibly learned – per-proposal scoring (for example using a classification score)", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 326, + 505, + 339 + ], + "spans": [ + { + "bbox": [ + 106, + 326, + 505, + 339 + ], + "score": 1.0, + "content": "and a notion of how dissimilar a pair of proposals are. Since each step in the component has a clear", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 337, + 506, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 337, + 506, + 351 + ], + "score": 1.0, + "content": "purpose and interpretation, the learned weights of the activation functions are also interpretable. The", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 348, + 505, + 361 + ], + "spans": [ + { + "bbox": [ + 106, + 348, + 505, + 361 + ], + "score": 1.0, + "content": "design of the counting component is an example showing how by encoding inductive biases into a", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 358, + 506, + 372 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 506, + 372 + ], + "score": 1.0, + "content": "deep learning model, challenging problems such as counting of arbitrary objects can be approached", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 370, + 359, + 383 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 359, + 383 + ], + "score": 1.0, + "content": "when only relatively little supervisory information is available.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 387, + 505, + 421 + ], + "lines": [ + { + "bbox": [ + 105, + 387, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 105, + 387, + 505, + 400 + ], + "score": 1.0, + "content": "For future research, it should be kept in mind that VQA v2 requires a versatile skill set that current", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "score": 1.0, + "content": "models do not have. To make progress on this dataset, we advocate focusing on understanding of", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 408, + 427, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 427, + 423 + ], + "score": 1.0, + "content": "what the current shortcomings of models are and finding ways to mitigate them.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25 + }, + { + "type": "title", + "bbox": [ + 107, + 437, + 175, + 449 + ], + "lines": [ + { + "bbox": [ + 106, + 436, + 176, + 451 + ], + "spans": [ + { + "bbox": [ + 106, + 436, + 176, + 451 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 105, + 455, + 506, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 455, + 506, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 506, + 469 + ], + "score": 1.0, + "content": "Peter Anderson, Xiaodong He, Chris Buehler, Damien Teney, Mark Johnson, Stephen Gould,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 116, + 466, + 507, + 480 + ], + "spans": [ + { + "bbox": [ + 116, + 466, + 507, + 480 + ], + "score": 1.0, + "content": "and Lei Zhang. Bottom-up and top-down attention for image captioning and VQA. CoRR,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 116, + 478, + 219, + 488 + ], + "spans": [ + { + "bbox": [ + 116, + 478, + 219, + 488 + ], + "score": 1.0, + "content": "arXiv:1707.07998, 2017.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 495, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 106, + 495, + 506, + 509 + ], + "score": 1.0, + "content": "Stanislaw Antol, Aishwarya Agrawal, Jiasen Lu, Margaret Mitchell, Dhruv Batra, C. Lawrence", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 116, + 506, + 427, + 519 + ], + "spans": [ + { + "bbox": [ + 116, + 506, + 427, + 519 + ], + "score": 1.0, + "content": "Zitnick, and Devi Parikh. VQA: Visual Question Answering. In ICCV, 2015.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 523, + 506, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 506, + 538 + ], + "score": 1.0, + "content": "Samaneh Azadi, Jiashi Feng, and Trevor Darrell. Learning detection with diverse proposals. In", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 117, + 536, + 171, + 546 + ], + "spans": [ + { + "bbox": [ + 117, + 536, + 171, + 546 + ], + "score": 1.0, + "content": "CVPR, 2017.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 553, + 505, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 553, + 505, + 567 + ], + "score": 1.0, + "content": "Jimmy Ba, Volodymyr Mnih, and Koray Kavukcuoglu. Multiple object recognition with visual", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 566, + 219, + 576 + ], + "spans": [ + { + "bbox": [ + 116, + 566, + 219, + 576 + ], + "score": 1.0, + "content": "attention. In ICLR, 2015.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 582, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 596 + ], + "score": 1.0, + "content": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 594, + 303, + 606 + ], + "spans": [ + { + "bbox": [ + 115, + 594, + 303, + 606 + ], + "score": 1.0, + "content": "learning to align and translate. In ICLR, 2015.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 611, + 506, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 506, + 625 + ], + "score": 1.0, + "content": "Prithvijit Chattopadhyay, Ramakrishna Vedantam, Ramprasaath R. Selvaraju, Dhruv Batra, and Devi", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 622, + 405, + 636 + ], + "spans": [ + { + "bbox": [ + 115, + 622, + 405, + 636 + ], + "score": 1.0, + "content": "Parikh. Counting everyday objects in everyday scenes. In CVPR, 2017.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 641, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 505, + 653 + ], + "score": 1.0, + "content": "Kyunghyun Cho, B van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties of", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 651, + 452, + 664 + ], + "spans": [ + { + "bbox": [ + 115, + 651, + 452, + 664 + ], + "score": 1.0, + "content": "neural machine translation: Encoder-decoder approaches. In SSST@EMNLP, 2014.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 670, + 505, + 682 + ], + "spans": [ + { + "bbox": [ + 106, + 670, + 505, + 682 + ], + "score": 1.0, + "content": "Joseph Paul Cohen, Henry Z. Lo, and Yoshua Bengio. Count-ception: Counting by fully convolutional", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 681, + 331, + 693 + ], + "spans": [ + { + "bbox": [ + 115, + 681, + 331, + 693 + ], + "score": 1.0, + "content": "redundant counting. CoRR, arXiv:1703.08710, 2017.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "Yash Goyal, Tejas Khot, Douglas Summers-Stay, Dhruv Batra, and Devi Parikh. Making the V in", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 115, + 709, + 507, + 723 + ], + "spans": [ + { + "bbox": [ + 115, + 709, + 507, + 723 + ], + "score": 1.0, + "content": "VQA matter: Elevating the role of image understanding in Visual Question Answering. In CVPR,", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 116, + 720, + 142, + 733 + ], + "spans": [ + { + "bbox": [ + 116, + 720, + 142, + 733 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 37.5 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "10", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 148 + ], + "lines": [], + "index": 2.5, + "bbox_fs": [ + 104, + 82, + 506, + 149 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 154, + 505, + 220 + ], + "lines": [ + { + "bbox": [ + 105, + 153, + 506, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 506, + 167 + ], + "score": 1.0, + "content": "When looking at the activation functions of the trained model, shown in Figure 9, we find that some", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 165, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 106, + 165, + 505, + 177 + ], + "score": 1.0, + "content": "characteristics of them are shared with high-noise parametrizations of the toy dataset. This suggests", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "score": 1.0, + "content": "that the current attention mechanisms and object proposal network are still very inaccurate, which", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 505, + 200 + ], + "score": 1.0, + "content": "explains the perhaps small-seeming increase in counting performance. This provides further evidence", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 505, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 505, + 211 + ], + "score": 1.0, + "content": "that the balanced pair accuracy is maybe a more reflective measure of how well current VQA models", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 209, + 430, + 221 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 303, + 221 + ], + "score": 1.0, + "content": "perform than the overall VQA accuracies of over", + "type": "text" + }, + { + "bbox": [ + 304, + 209, + 324, + 220 + ], + "score": 0.88, + "content": "70 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 209, + 430, + 221 + ], + "score": 1.0, + "content": "of the current top models.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 153, + 506, + 221 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 236, + 195, + 249 + ], + "lines": [ + { + "bbox": [ + 105, + 235, + 197, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 197, + 252 + ], + "score": 1.0, + "content": "6 CONCLUSION", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 261, + 505, + 382 + ], + "lines": [ + { + "bbox": [ + 106, + 261, + 506, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 506, + 273 + ], + "score": 1.0, + "content": "After understanding why VQA models struggle to count, we designed a counting component that", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 272, + 505, + 285 + ], + "spans": [ + { + "bbox": [ + 105, + 272, + 505, + 285 + ], + "score": 1.0, + "content": "alleviates this problem through differentiable bounding box deduplication. The component can readily", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 283, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 106, + 283, + 505, + 295 + ], + "score": 1.0, + "content": "be used alongside any future improvements in VQA models, as long as they still use soft attention as", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 293, + 506, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 506, + 307 + ], + "score": 1.0, + "content": "all current top models on VQA v2 do. It has uses outside of VQA as well: for many counting tasks,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 305, + 506, + 317 + ], + "spans": [ + { + "bbox": [ + 105, + 305, + 506, + 317 + ], + "score": 1.0, + "content": "it can allow an object-proposal-based approach to work without ground-truth objects available as", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 315, + 506, + 329 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 506, + 329 + ], + "score": 1.0, + "content": "long as there is a – possibly learned – per-proposal scoring (for example using a classification score)", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 326, + 505, + 339 + ], + "spans": [ + { + "bbox": [ + 106, + 326, + 505, + 339 + ], + "score": 1.0, + "content": "and a notion of how dissimilar a pair of proposals are. Since each step in the component has a clear", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 337, + 506, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 337, + 506, + 351 + ], + "score": 1.0, + "content": "purpose and interpretation, the learned weights of the activation functions are also interpretable. The", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 348, + 505, + 361 + ], + "spans": [ + { + "bbox": [ + 106, + 348, + 505, + 361 + ], + "score": 1.0, + "content": "design of the counting component is an example showing how by encoding inductive biases into a", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 358, + 506, + 372 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 506, + 372 + ], + "score": 1.0, + "content": "deep learning model, challenging problems such as counting of arbitrary objects can be approached", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 370, + 359, + 383 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 359, + 383 + ], + "score": 1.0, + "content": "when only relatively little supervisory information is available.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 261, + 506, + 383 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 387, + 505, + 421 + ], + "lines": [ + { + "bbox": [ + 105, + 387, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 105, + 387, + 505, + 400 + ], + "score": 1.0, + "content": "For future research, it should be kept in mind that VQA v2 requires a versatile skill set that current", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 505, + 411 + ], + "score": 1.0, + "content": "models do not have. To make progress on this dataset, we advocate focusing on understanding of", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 408, + 427, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 427, + 423 + ], + "score": 1.0, + "content": "what the current shortcomings of models are and finding ways to mitigate them.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 387, + 505, + 423 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 437, + 175, + 449 + ], + "lines": [ + { + "bbox": [ + 106, + 436, + 176, + 451 + ], + "spans": [ + { + "bbox": [ + 106, + 436, + 176, + 451 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "list", + "bbox": [ + 105, + 455, + 506, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 455, + 506, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 506, + 469 + ], + "score": 1.0, + "content": "Peter Anderson, Xiaodong He, Chris Buehler, Damien Teney, Mark Johnson, Stephen Gould,", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 466, + 507, + 480 + ], + "spans": [ + { + "bbox": [ + 116, + 466, + 507, + 480 + ], + "score": 1.0, + "content": "and Lei Zhang. Bottom-up and top-down attention for image captioning and VQA. CoRR,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 116, + 478, + 219, + 488 + ], + "spans": [ + { + "bbox": [ + 116, + 478, + 219, + 488 + ], + "score": 1.0, + "content": "arXiv:1707.07998, 2017.", + "type": "text" + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 495, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 106, + 495, + 506, + 509 + ], + "score": 1.0, + "content": "Stanislaw Antol, Aishwarya Agrawal, Jiasen Lu, Margaret Mitchell, Dhruv Batra, C. Lawrence", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 506, + 427, + 519 + ], + "spans": [ + { + "bbox": [ + 116, + 506, + 427, + 519 + ], + "score": 1.0, + "content": "Zitnick, and Devi Parikh. VQA: Visual Question Answering. In ICCV, 2015.", + "type": "text" + } + ], + "index": 32, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 523, + 506, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 506, + 538 + ], + "score": 1.0, + "content": "Samaneh Azadi, Jiashi Feng, and Trevor Darrell. Learning detection with diverse proposals. In", + "type": "text" + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 117, + 536, + 171, + 546 + ], + "spans": [ + { + "bbox": [ + 117, + 536, + 171, + 546 + ], + "score": 1.0, + "content": "CVPR, 2017.", + "type": "text" + } + ], + "index": 34, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 553, + 505, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 553, + 505, + 567 + ], + "score": 1.0, + "content": "Jimmy Ba, Volodymyr Mnih, and Koray Kavukcuoglu. Multiple object recognition with visual", + "type": "text" + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 566, + 219, + 576 + ], + "spans": [ + { + "bbox": [ + 116, + 566, + 219, + 576 + ], + "score": 1.0, + "content": "attention. In ICLR, 2015.", + "type": "text" + } + ], + "index": 36, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 582, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 596 + ], + "score": 1.0, + "content": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 594, + 303, + 606 + ], + "spans": [ + { + "bbox": [ + 115, + 594, + 303, + 606 + ], + "score": 1.0, + "content": "learning to align and translate. In ICLR, 2015.", + "type": "text" + } + ], + "index": 38, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 611, + 506, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 506, + 625 + ], + "score": 1.0, + "content": "Prithvijit Chattopadhyay, Ramakrishna Vedantam, Ramprasaath R. Selvaraju, Dhruv Batra, and Devi", + "type": "text" + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 622, + 405, + 636 + ], + "spans": [ + { + "bbox": [ + 115, + 622, + 405, + 636 + ], + "score": 1.0, + "content": "Parikh. Counting everyday objects in everyday scenes. In CVPR, 2017.", + "type": "text" + } + ], + "index": 40, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 641, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 505, + 653 + ], + "score": 1.0, + "content": "Kyunghyun Cho, B van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties of", + "type": "text" + } + ], + "index": 41, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 651, + 452, + 664 + ], + "spans": [ + { + "bbox": [ + 115, + 651, + 452, + 664 + ], + "score": 1.0, + "content": "neural machine translation: Encoder-decoder approaches. In SSST@EMNLP, 2014.", + "type": "text" + } + ], + "index": 42, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 670, + 505, + 682 + ], + "spans": [ + { + "bbox": [ + 106, + 670, + 505, + 682 + ], + "score": 1.0, + "content": "Joseph Paul Cohen, Henry Z. Lo, and Yoshua Bengio. Count-ception: Counting by fully convolutional", + "type": "text" + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 681, + 331, + 693 + ], + "spans": [ + { + "bbox": [ + 115, + 681, + 331, + 693 + ], + "score": 1.0, + "content": "redundant counting. CoRR, arXiv:1703.08710, 2017.", + "type": "text" + } + ], + "index": 44, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "Yash Goyal, Tejas Khot, Douglas Summers-Stay, Dhruv Batra, and Devi Parikh. Making the V in", + "type": "text" + } + ], + "index": 45, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 709, + 507, + 723 + ], + "spans": [ + { + "bbox": [ + 115, + 709, + 507, + 723 + ], + "score": 1.0, + "content": "VQA matter: Elevating the role of image understanding in Visual Question Answering. In CVPR,", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 116, + 720, + 142, + 733 + ], + "spans": [ + { + "bbox": [ + 116, + 720, + 142, + 733 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 47, + "is_list_end_line": true + } + ], + "index": 37.5, + "bbox_fs": [ + 105, + 455, + 507, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 506, + 97 + ], + "score": 1.0, + "content": "Paul Henderson and Vittorio Ferrari. End-to-end training of object class detectors for mean average", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 94, + 225, + 104 + ], + "spans": [ + { + "bbox": [ + 115, + 94, + 225, + 104 + ], + "score": 1.0, + "content": "precision. In ACCV, 2017.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 107, + 111, + 496, + 124 + ], + "lines": [ + { + "bbox": [ + 105, + 110, + 497, + 126 + ], + "spans": [ + { + "bbox": [ + 105, + 110, + 497, + 126 + ], + "score": 1.0, + "content": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Computation, 1997.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 105, + 130, + 505, + 154 + ], + "lines": [ + { + "bbox": [ + 105, + 129, + 506, + 143 + ], + "spans": [ + { + "bbox": [ + 105, + 129, + 506, + 143 + ], + "score": 1.0, + "content": "Jan Hosang, Rodrigo Benenson, and Bernt Schiele. Learning non-maximum suppression. In CVPR,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 140, + 143, + 154 + ], + "spans": [ + { + "bbox": [ + 115, + 140, + 143, + 154 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 106, + 159, + 505, + 183 + ], + "lines": [ + { + "bbox": [ + 105, + 159, + 505, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 505, + 174 + ], + "score": 1.0, + "content": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 116, + 171, + 314, + 182 + ], + "spans": [ + { + "bbox": [ + 116, + 171, + 314, + 182 + ], + "score": 1.0, + "content": "reducing internal covariate shift. In ICML, 2015.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 107, + 189, + 505, + 212 + ], + "lines": [ + { + "bbox": [ + 104, + 186, + 506, + 204 + ], + "spans": [ + { + "bbox": [ + 104, + 186, + 506, + 204 + ], + "score": 1.0, + "content": "Allan Jabri, Armand Joulin, and Laurens van der Maaten. Revisiting visual question answering", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 117, + 200, + 225, + 212 + ], + "spans": [ + { + "bbox": [ + 117, + 200, + 225, + 212 + ], + "score": 1.0, + "content": "baselines. In ECCV, 2016.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 106, + 218, + 505, + 242 + ], + "lines": [ + { + "bbox": [ + 105, + 218, + 505, + 232 + ], + "spans": [ + { + "bbox": [ + 105, + 218, + 505, + 232 + ], + "score": 1.0, + "content": "Max Jaderberg, Karen Simonyan, Andrew Zisserman, and Koray Kavukcuoglu. Spatial transformer", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 230, + 221, + 241 + ], + "spans": [ + { + "bbox": [ + 115, + 230, + 221, + 241 + ], + "score": 1.0, + "content": "networks. In NIPS, 2015.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 107, + 248, + 505, + 282 + ], + "lines": [ + { + "bbox": [ + 106, + 248, + 505, + 261 + ], + "spans": [ + { + "bbox": [ + 106, + 248, + 505, + 261 + ], + "score": 1.0, + "content": "Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C. Lawrence Zitnick, and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 259, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 116, + 259, + 505, + 272 + ], + "score": 1.0, + "content": "Ross Girshick. CLEVR: A diagnostic dataset for compositional language and elementary visual", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 271, + 228, + 283 + ], + "spans": [ + { + "bbox": [ + 115, + 271, + 228, + 283 + ], + "score": 1.0, + "content": "reasoning. In CVPR, 2017.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 105, + 288, + 505, + 312 + ], + "lines": [ + { + "bbox": [ + 106, + 289, + 505, + 302 + ], + "spans": [ + { + "bbox": [ + 106, + 289, + 505, + 302 + ], + "score": 1.0, + "content": "Vahid Kazemi and Ali Elqursh. Show, ask, attend, and answer: A strong baseline for visual question", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 300, + 294, + 311 + ], + "spans": [ + { + "bbox": [ + 115, + 300, + 294, + 311 + ], + "score": 1.0, + "content": "answering. CoRR, arXiv:1704.03162, 2017.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5 + }, + { + "type": "text", + "bbox": [ + 106, + 318, + 504, + 341 + ], + "lines": [ + { + "bbox": [ + 106, + 318, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 318, + 505, + 331 + ], + "score": 1.0, + "content": "Yoon Kim, Carl Denton, Luong Hoang, and Alexander M. Rush. Structured attention networks. In", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 115, + 328, + 169, + 342 + ], + "spans": [ + { + "bbox": [ + 115, + 328, + 169, + 342 + ], + "score": 1.0, + "content": "ICLR, 2017.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16.5 + }, + { + "type": "text", + "bbox": [ + 106, + 347, + 498, + 361 + ], + "lines": [ + { + "bbox": [ + 106, + 346, + 498, + 361 + ], + "spans": [ + { + "bbox": [ + 106, + 346, + 498, + 361 + ], + "score": 1.0, + "content": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 106, + 366, + 503, + 389 + ], + "lines": [ + { + "bbox": [ + 106, + 366, + 504, + 379 + ], + "spans": [ + { + "bbox": [ + 106, + 366, + 504, + 379 + ], + "score": 1.0, + "content": "Hugo Larochelle and Geoffrey E Hinton. Learning to combine foveal glimpses with a third-order", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 378, + 262, + 389 + ], + "spans": [ + { + "bbox": [ + 116, + 378, + 262, + 389 + ], + "score": 1.0, + "content": "boltzmann machine. In NIPS, 2010.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 106, + 395, + 488, + 408 + ], + "lines": [ + { + "bbox": [ + 106, + 395, + 488, + 409 + ], + "spans": [ + { + "bbox": [ + 106, + 395, + 488, + 409 + ], + "score": 1.0, + "content": "Victor Lempitsky and Andrew Zisserman. Learning to count objects in images. In NIPS, 2010.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 106, + 414, + 504, + 437 + ], + "lines": [ + { + "bbox": [ + 106, + 415, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 106, + 415, + 505, + 428 + ], + "score": 1.0, + "content": "Jiasen Lu, Jianwei Yang, Dhruv Batra, and Devi Parikh. Hierarchical question-image co-attention for", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 425, + 288, + 438 + ], + "spans": [ + { + "bbox": [ + 116, + 425, + 288, + 438 + ], + "score": 1.0, + "content": "visual question answering. In NIPS, 2016.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 107, + 443, + 413, + 456 + ], + "lines": [ + { + "bbox": [ + 106, + 443, + 412, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 443, + 412, + 457 + ], + "score": 1.0, + "content": "Dmytro Mishkin and Jiri Matas. All you need is a good init. In ICLR, 2016.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 462, + 502, + 485 + ], + "lines": [ + { + "bbox": [ + 106, + 461, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 505, + 475 + ], + "score": 1.0, + "content": "Volodymyr Mnih, Nicolas Heess, Alex Graves, and Koray Kavukcuoglu. Recurrent models of visual", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 116, + 474, + 219, + 484 + ], + "spans": [ + { + "bbox": [ + 116, + 474, + 219, + 484 + ], + "score": 1.0, + "content": "attention. In NIPS, 2014.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 106, + 491, + 503, + 515 + ], + "lines": [ + { + "bbox": [ + 106, + 491, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 106, + 491, + 505, + 504 + ], + "score": 1.0, + "content": "Ethan Perez, Florian Strub, Harm de Vries, Vincent Dumoulin, and Aaron Courville. FiLM: Visual", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 503, + 426, + 515 + ], + "spans": [ + { + "bbox": [ + 115, + 503, + 426, + 515 + ], + "score": 1.0, + "content": "reasoning with a general conditioning layer. CoRR, arXiv:1709.07871, 2017.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 106, + 521, + 503, + 544 + ], + "lines": [ + { + "bbox": [ + 106, + 521, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 521, + 505, + 534 + ], + "score": 1.0, + "content": "Mengye Ren and Richard S. Zemel. End-to-end instance segmentation with recurrent attention. In", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 116, + 532, + 172, + 544 + ], + "spans": [ + { + "bbox": [ + 116, + 532, + 172, + 544 + ], + "score": 1.0, + "content": "CVPR, 2017.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 106, + 550, + 506, + 585 + ], + "lines": [ + { + "bbox": [ + 106, + 551, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 106, + 551, + 505, + 563 + ], + "score": 1.0, + "content": "Adam Santoro, David Raposo, David G. T. Barrett, Mateusz Malinowski, Razvan Pascanu, Peter", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 116, + 562, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 116, + 562, + 505, + 574 + ], + "score": 1.0, + "content": "Battaglia, and Timothy P. Lillicrap. A simple neural network module for relational reasoning. In", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 573, + 168, + 585 + ], + "spans": [ + { + "bbox": [ + 115, + 573, + 168, + 585 + ], + "score": 1.0, + "content": "NIPS, 2017.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 108, + 591, + 503, + 615 + ], + "lines": [ + { + "bbox": [ + 106, + 591, + 505, + 604 + ], + "spans": [ + { + "bbox": [ + 106, + 591, + 505, + 604 + ], + "score": 1.0, + "content": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 116, + 602, + 445, + 615 + ], + "spans": [ + { + "bbox": [ + 116, + 602, + 445, + 615 + ], + "score": 1.0, + "content": "Dropout: A simple way to prevent neural networks from overfitting. JMLR, 2014.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5 + }, + { + "type": "text", + "bbox": [ + 106, + 620, + 503, + 644 + ], + "lines": [ + { + "bbox": [ + 106, + 620, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 620, + 505, + 633 + ], + "score": 1.0, + "content": "Damien Teney, Peter Anderson, Xiaodong He, and Anton van den Hengel. Tips and tricks for visual", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 116, + 633, + 477, + 644 + ], + "spans": [ + { + "bbox": [ + 116, + 633, + 477, + 644 + ], + "score": 1.0, + "content": "question answering: Learnings from the 2017 challenge. CoRR, arXiv:1708.02711, 2017.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 106, + 650, + 504, + 674 + ], + "lines": [ + { + "bbox": [ + 106, + 650, + 505, + 663 + ], + "spans": [ + { + "bbox": [ + 106, + 650, + 505, + 663 + ], + "score": 1.0, + "content": "Alexander Trott, Caiming Xiong, and Richard Socher. Interpretable counting for visual question", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 662, + 225, + 673 + ], + "spans": [ + { + "bbox": [ + 116, + 662, + 225, + 673 + ], + "score": 1.0, + "content": "answering. In ICLR, 2018.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5 + }, + { + "type": "text", + "bbox": [ + 106, + 680, + 503, + 703 + ], + "lines": [ + { + "bbox": [ + 106, + 680, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 106, + 680, + 505, + 693 + ], + "score": 1.0, + "content": "Zichao Yang, Xiaodong He, Jianfeng Gao, Li Deng, and Alexander J. Smola. Stacked attention", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 115, + 690, + 345, + 703 + ], + "spans": [ + { + "bbox": [ + 115, + 690, + 345, + 703 + ], + "score": 1.0, + "content": "networks for image question answering. In CVPR, 2016.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5 + }, + { + "type": "text", + "bbox": [ + 108, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "Seungil You, David Ding, Kevin Canini, Jan Pfeifer, and Maya Gupta. Deep Lattice Networks and", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 720, + 298, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 720, + 298, + 732 + ], + "score": 1.0, + "content": "Partial Monotonic Functions. In NIPS, 2017.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 26, + 293, + 38 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 39 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 39 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 761 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "score": 1.0, + "content": "11", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 506, + 97 + ], + "score": 1.0, + "content": "Paul Henderson and Vittorio Ferrari. End-to-end training of object class detectors for mean average", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 94, + 225, + 104 + ], + "spans": [ + { + "bbox": [ + 115, + 94, + 225, + 104 + ], + "score": 1.0, + "content": "precision. In ACCV, 2017.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 105, + 80, + 506, + 104 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 111, + 496, + 124 + ], + "lines": [ + { + "bbox": [ + 105, + 110, + 497, + 126 + ], + "spans": [ + { + "bbox": [ + 105, + 110, + 497, + 126 + ], + "score": 1.0, + "content": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Computation, 1997.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2, + "bbox_fs": [ + 105, + 110, + 497, + 126 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 130, + 505, + 154 + ], + "lines": [ + { + "bbox": [ + 105, + 129, + 506, + 143 + ], + "spans": [ + { + "bbox": [ + 105, + 129, + 506, + 143 + ], + "score": 1.0, + "content": "Jan Hosang, Rodrigo Benenson, and Bernt Schiele. Learning non-maximum suppression. In CVPR,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 140, + 143, + 154 + ], + "spans": [ + { + "bbox": [ + 115, + 140, + 143, + 154 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 129, + 506, + 154 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 159, + 505, + 183 + ], + "lines": [ + { + "bbox": [ + 105, + 159, + 505, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 505, + 174 + ], + "score": 1.0, + "content": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 116, + 171, + 314, + 182 + ], + "spans": [ + { + "bbox": [ + 116, + 171, + 314, + 182 + ], + "score": 1.0, + "content": "reducing internal covariate shift. In ICML, 2015.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5, + "bbox_fs": [ + 105, + 159, + 505, + 182 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 189, + 505, + 212 + ], + "lines": [ + { + "bbox": [ + 104, + 186, + 506, + 204 + ], + "spans": [ + { + "bbox": [ + 104, + 186, + 506, + 204 + ], + "score": 1.0, + "content": "Allan Jabri, Armand Joulin, and Laurens van der Maaten. Revisiting visual question answering", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 117, + 200, + 225, + 212 + ], + "spans": [ + { + "bbox": [ + 117, + 200, + 225, + 212 + ], + "score": 1.0, + "content": "baselines. In ECCV, 2016.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5, + "bbox_fs": [ + 104, + 186, + 506, + 212 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 218, + 505, + 242 + ], + "lines": [ + { + "bbox": [ + 105, + 218, + 505, + 232 + ], + "spans": [ + { + "bbox": [ + 105, + 218, + 505, + 232 + ], + "score": 1.0, + "content": "Max Jaderberg, Karen Simonyan, Andrew Zisserman, and Koray Kavukcuoglu. Spatial transformer", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 230, + 221, + 241 + ], + "spans": [ + { + "bbox": [ + 115, + 230, + 221, + 241 + ], + "score": 1.0, + "content": "networks. In NIPS, 2015.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 218, + 505, + 241 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 248, + 505, + 282 + ], + "lines": [ + { + "bbox": [ + 106, + 248, + 505, + 261 + ], + "spans": [ + { + "bbox": [ + 106, + 248, + 505, + 261 + ], + "score": 1.0, + "content": "Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C. Lawrence Zitnick, and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 259, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 116, + 259, + 505, + 272 + ], + "score": 1.0, + "content": "Ross Girshick. CLEVR: A diagnostic dataset for compositional language and elementary visual", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 271, + 228, + 283 + ], + "spans": [ + { + "bbox": [ + 115, + 271, + 228, + 283 + ], + "score": 1.0, + "content": "reasoning. In CVPR, 2017.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12, + "bbox_fs": [ + 106, + 248, + 505, + 283 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 288, + 505, + 312 + ], + "lines": [ + { + "bbox": [ + 106, + 289, + 505, + 302 + ], + "spans": [ + { + "bbox": [ + 106, + 289, + 505, + 302 + ], + "score": 1.0, + "content": "Vahid Kazemi and Ali Elqursh. Show, ask, attend, and answer: A strong baseline for visual question", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 300, + 294, + 311 + ], + "spans": [ + { + "bbox": [ + 115, + 300, + 294, + 311 + ], + "score": 1.0, + "content": "answering. CoRR, arXiv:1704.03162, 2017.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5, + "bbox_fs": [ + 106, + 289, + 505, + 311 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 318, + 504, + 341 + ], + "lines": [ + { + "bbox": [ + 106, + 318, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 318, + 505, + 331 + ], + "score": 1.0, + "content": "Yoon Kim, Carl Denton, Luong Hoang, and Alexander M. Rush. Structured attention networks. In", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 115, + 328, + 169, + 342 + ], + "spans": [ + { + "bbox": [ + 115, + 328, + 169, + 342 + ], + "score": 1.0, + "content": "ICLR, 2017.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16.5, + "bbox_fs": [ + 106, + 318, + 505, + 342 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 347, + 498, + 361 + ], + "lines": [ + { + "bbox": [ + 106, + 346, + 498, + 361 + ], + "spans": [ + { + "bbox": [ + 106, + 346, + 498, + 361 + ], + "score": 1.0, + "content": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18, + "bbox_fs": [ + 106, + 346, + 498, + 361 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 366, + 503, + 389 + ], + "lines": [ + { + "bbox": [ + 106, + 366, + 504, + 379 + ], + "spans": [ + { + "bbox": [ + 106, + 366, + 504, + 379 + ], + "score": 1.0, + "content": "Hugo Larochelle and Geoffrey E Hinton. Learning to combine foveal glimpses with a third-order", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 378, + 262, + 389 + ], + "spans": [ + { + "bbox": [ + 116, + 378, + 262, + 389 + ], + "score": 1.0, + "content": "boltzmann machine. In NIPS, 2010.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5, + "bbox_fs": [ + 106, + 366, + 504, + 389 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 395, + 488, + 408 + ], + "lines": [ + { + "bbox": [ + 106, + 395, + 488, + 409 + ], + "spans": [ + { + "bbox": [ + 106, + 395, + 488, + 409 + ], + "score": 1.0, + "content": "Victor Lempitsky and Andrew Zisserman. Learning to count objects in images. In NIPS, 2010.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21, + "bbox_fs": [ + 106, + 395, + 488, + 409 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 414, + 504, + 437 + ], + "lines": [ + { + "bbox": [ + 106, + 415, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 106, + 415, + 505, + 428 + ], + "score": 1.0, + "content": "Jiasen Lu, Jianwei Yang, Dhruv Batra, and Devi Parikh. Hierarchical question-image co-attention for", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 425, + 288, + 438 + ], + "spans": [ + { + "bbox": [ + 116, + 425, + 288, + 438 + ], + "score": 1.0, + "content": "visual question answering. In NIPS, 2016.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 106, + 415, + 505, + 438 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 443, + 413, + 456 + ], + "lines": [ + { + "bbox": [ + 106, + 443, + 412, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 443, + 412, + 457 + ], + "score": 1.0, + "content": "Dmytro Mishkin and Jiri Matas. All you need is a good init. In ICLR, 2016.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24, + "bbox_fs": [ + 106, + 443, + 412, + 457 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 462, + 502, + 485 + ], + "lines": [ + { + "bbox": [ + 106, + 461, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 505, + 475 + ], + "score": 1.0, + "content": "Volodymyr Mnih, Nicolas Heess, Alex Graves, and Koray Kavukcuoglu. Recurrent models of visual", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 116, + 474, + 219, + 484 + ], + "spans": [ + { + "bbox": [ + 116, + 474, + 219, + 484 + ], + "score": 1.0, + "content": "attention. In NIPS, 2014.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5, + "bbox_fs": [ + 106, + 461, + 505, + 484 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 491, + 503, + 515 + ], + "lines": [ + { + "bbox": [ + 106, + 491, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 106, + 491, + 505, + 504 + ], + "score": 1.0, + "content": "Ethan Perez, Florian Strub, Harm de Vries, Vincent Dumoulin, and Aaron Courville. FiLM: Visual", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 503, + 426, + 515 + ], + "spans": [ + { + "bbox": [ + 115, + 503, + 426, + 515 + ], + "score": 1.0, + "content": "reasoning with a general conditioning layer. CoRR, arXiv:1709.07871, 2017.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5, + "bbox_fs": [ + 106, + 491, + 505, + 515 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 521, + 503, + 544 + ], + "lines": [ + { + "bbox": [ + 106, + 521, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 521, + 505, + 534 + ], + "score": 1.0, + "content": "Mengye Ren and Richard S. Zemel. End-to-end instance segmentation with recurrent attention. In", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 116, + 532, + 172, + 544 + ], + "spans": [ + { + "bbox": [ + 116, + 532, + 172, + 544 + ], + "score": 1.0, + "content": "CVPR, 2017.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5, + "bbox_fs": [ + 106, + 521, + 505, + 544 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 550, + 506, + 585 + ], + "lines": [ + { + "bbox": [ + 106, + 551, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 106, + 551, + 505, + 563 + ], + "score": 1.0, + "content": "Adam Santoro, David Raposo, David G. T. Barrett, Mateusz Malinowski, Razvan Pascanu, Peter", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 116, + 562, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 116, + 562, + 505, + 574 + ], + "score": 1.0, + "content": "Battaglia, and Timothy P. Lillicrap. A simple neural network module for relational reasoning. In", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 573, + 168, + 585 + ], + "spans": [ + { + "bbox": [ + 115, + 573, + 168, + 585 + ], + "score": 1.0, + "content": "NIPS, 2017.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32, + "bbox_fs": [ + 106, + 551, + 505, + 585 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 591, + 503, + 615 + ], + "lines": [ + { + "bbox": [ + 106, + 591, + 505, + 604 + ], + "spans": [ + { + "bbox": [ + 106, + 591, + 505, + 604 + ], + "score": 1.0, + "content": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 116, + 602, + 445, + 615 + ], + "spans": [ + { + "bbox": [ + 116, + 602, + 445, + 615 + ], + "score": 1.0, + "content": "Dropout: A simple way to prevent neural networks from overfitting. JMLR, 2014.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5, + "bbox_fs": [ + 106, + 591, + 505, + 615 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 620, + 503, + 644 + ], + "lines": [ + { + "bbox": [ + 106, + 620, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 620, + 505, + 633 + ], + "score": 1.0, + "content": "Damien Teney, Peter Anderson, Xiaodong He, and Anton van den Hengel. Tips and tricks for visual", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 116, + 633, + 477, + 644 + ], + "spans": [ + { + "bbox": [ + 116, + 633, + 477, + 644 + ], + "score": 1.0, + "content": "question answering: Learnings from the 2017 challenge. CoRR, arXiv:1708.02711, 2017.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5, + "bbox_fs": [ + 106, + 620, + 505, + 644 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 650, + 504, + 674 + ], + "lines": [ + { + "bbox": [ + 106, + 650, + 505, + 663 + ], + "spans": [ + { + "bbox": [ + 106, + 650, + 505, + 663 + ], + "score": 1.0, + "content": "Alexander Trott, Caiming Xiong, and Richard Socher. Interpretable counting for visual question", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 662, + 225, + 673 + ], + "spans": [ + { + "bbox": [ + 116, + 662, + 225, + 673 + ], + "score": 1.0, + "content": "answering. In ICLR, 2018.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5, + "bbox_fs": [ + 106, + 650, + 505, + 673 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 680, + 503, + 703 + ], + "lines": [ + { + "bbox": [ + 106, + 680, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 106, + 680, + 505, + 693 + ], + "score": 1.0, + "content": "Zichao Yang, Xiaodong He, Jianfeng Gao, Li Deng, and Alexander J. Smola. Stacked attention", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 115, + 690, + 345, + 703 + ], + "spans": [ + { + "bbox": [ + 115, + 690, + 345, + 703 + ], + "score": 1.0, + "content": "networks for image question answering. In CVPR, 2016.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5, + "bbox_fs": [ + 106, + 680, + 505, + 703 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "Seungil You, David Ding, Kevin Canini, Jan Pfeifer, and Maya Gupta. Deep Lattice Networks and", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 720, + 298, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 720, + 298, + 732 + ], + "score": 1.0, + "content": "Partial Monotonic Functions. In NIPS, 2017.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5, + "bbox_fs": [ + 106, + 709, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 505, + 115 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 505, + 95 + ], + "score": 1.0, + "content": "Yu Zhou, Yu Jun, Xiang Chenchao, Fan Jianping, and Tao Dacheng. Beyond bilinear: Generalized", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 93, + 506, + 105 + ], + "spans": [ + { + "bbox": [ + 115, + 93, + 506, + 105 + ], + "score": 1.0, + "content": "multi-modal factorized high-order pooling for visual question answering. CoRR, arXiv:1708.03619,", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 103, + 143, + 116 + ], + "spans": [ + { + "bbox": [ + 115, + 103, + 143, + 116 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 123, + 504, + 146 + ], + "lines": [ + { + "bbox": [ + 106, + 123, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 106, + 123, + 505, + 136 + ], + "score": 1.0, + "content": "Chen Zhu, Yanpeng Zhao, Shuaiyi Huang, Kewei Tu, and Yi Ma. Structured attentions for visual", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 116, + 135, + 331, + 147 + ], + "spans": [ + { + "bbox": [ + 116, + 135, + 331, + 147 + ], + "score": 1.0, + "content": "question answering. CoRR, arXiv:1708.02071, 2017.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "12", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 505, + 115 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 505, + 95 + ], + "score": 1.0, + "content": "Yu Zhou, Yu Jun, Xiang Chenchao, Fan Jianping, and Tao Dacheng. Beyond bilinear: Generalized", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 93, + 506, + 105 + ], + "spans": [ + { + "bbox": [ + 115, + 93, + 506, + 105 + ], + "score": 1.0, + "content": "multi-modal factorized high-order pooling for visual question answering. CoRR, arXiv:1708.03619,", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 103, + 143, + 116 + ], + "spans": [ + { + "bbox": [ + 115, + 103, + 143, + 116 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 106, + 81, + 506, + 116 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 123, + 504, + 146 + ], + "lines": [ + { + "bbox": [ + 106, + 123, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 106, + 123, + 505, + 136 + ], + "score": 1.0, + "content": "Chen Zhu, Yanpeng Zhao, Shuaiyi Huang, Kewei Tu, and Yi Ma. Structured attentions for visual", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 116, + 135, + 331, + 147 + ], + "spans": [ + { + "bbox": [ + 116, + 135, + 331, + 147 + ], + "score": 1.0, + "content": "question answering. CoRR, arXiv:1708.02071, 2017.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5, + "bbox_fs": [ + 106, + 123, + 505, + 147 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 82, + 349, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 350, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 350, + 96 + ], + "score": 1.0, + "content": "A PIECEWISE LINEAR ACTIVATION FUNCTION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 106, + 505, + 140 + ], + "lines": [ + { + "bbox": [ + 105, + 106, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 106, + 200, + 119 + ], + "score": 1.0, + "content": "Intuitively, the interval", + "type": "text" + }, + { + "bbox": [ + 200, + 106, + 221, + 119 + ], + "score": 0.26, + "content": "[ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 221, + 106, + 269, + 119 + ], + "score": 1.0, + "content": "is split into", + "type": "text" + }, + { + "bbox": [ + 270, + 107, + 276, + 117 + ], + "score": 0.77, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 277, + 106, + 505, + 119 + ], + "score": 1.0, + "content": "equal size intervals. Each contains a line segment that is", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 118, + 505, + 130 + ], + "spans": [ + { + "bbox": [ + 105, + 118, + 505, + 130 + ], + "score": 1.0, + "content": "connected to the neighboring line segments at the boundaries of the intervals. These line segments", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 129, + 272, + 140 + ], + "spans": [ + { + "bbox": [ + 106, + 129, + 272, + 140 + ], + "score": 1.0, + "content": "form the shape of the activation function.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 107, + 145, + 505, + 204 + ], + "lines": [ + { + "bbox": [ + 104, + 144, + 506, + 159 + ], + "spans": [ + { + "bbox": [ + 104, + 144, + 182, + 159 + ], + "score": 1.0, + "content": "For each function", + "type": "text" + }, + { + "bbox": [ + 182, + 146, + 192, + 157 + ], + "score": 0.85, + "content": "f _ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 193, + 144, + 235, + 159 + ], + "score": 1.0, + "content": ", there are", + "type": "text" + }, + { + "bbox": [ + 236, + 146, + 242, + 155 + ], + "score": 0.8, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 144, + 279, + 159 + ], + "score": 1.0, + "content": "weights", + "type": "text" + }, + { + "bbox": [ + 279, + 148, + 334, + 157 + ], + "score": 0.86, + "content": "w _ { k 1 } , \\ldots , w _ { k d }", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 144, + 412, + 159 + ], + "score": 1.0, + "content": ", where the weight", + "type": "text" + }, + { + "bbox": [ + 412, + 147, + 428, + 157 + ], + "score": 0.88, + "content": "w _ { k i }", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 144, + 506, + 159 + ], + "score": 1.0, + "content": "is the gradient for", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 103, + 154, + 507, + 172 + ], + "spans": [ + { + "bbox": [ + 103, + 154, + 155, + 172 + ], + "score": 1.0, + "content": "the interval", + "type": "text" + }, + { + "bbox": [ + 155, + 156, + 188, + 169 + ], + "score": 0.91, + "content": "[ \\textstyle { \\frac { i - 1 } { d } } , \\textstyle { \\frac { i } { d } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 154, + 265, + 172 + ], + "score": 1.0, + "content": ". We arbitrarily fix", + "type": "text" + }, + { + "bbox": [ + 265, + 157, + 272, + 167 + ], + "score": 0.8, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 272, + 154, + 507, + 172 + ], + "score": 1.0, + "content": "to be 16 in this paper, observing no significant difference", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 167, + 505, + 181 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 357, + 181 + ], + "score": 1.0, + "content": "when changing it to 8 and 32 in preliminary experiments. All", + "type": "text" + }, + { + "bbox": [ + 357, + 169, + 373, + 179 + ], + "score": 0.86, + "content": "w _ { k i }", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 167, + 505, + 181 + ], + "score": 1.0, + "content": "are enforced to be non-negative", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 179, + 505, + 191 + ], + "spans": [ + { + "bbox": [ + 106, + 179, + 505, + 191 + ], + "score": 1.0, + "content": "by always using the absolute value of them, which yields the monotonicity property. Dividing the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 189, + 461, + 205 + ], + "spans": [ + { + "bbox": [ + 104, + 191, + 152, + 205 + ], + "score": 1.0, + "content": "weights by", + "type": "text" + }, + { + "bbox": [ + 152, + 189, + 198, + 204 + ], + "score": 0.93, + "content": "\\Sigma _ { m } ^ { d } \\mid w _ { k m } \\mid", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 191, + 294, + 205 + ], + "score": 1.0, + "content": "yields the property that", + "type": "text" + }, + { + "bbox": [ + 294, + 191, + 332, + 204 + ], + "score": 0.93, + "content": "f ( 1 ) = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 332, + 191, + 461, + 205 + ], + "score": 1.0, + "content": ". The function can be written as", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6 + }, + { + "type": "interline_equation", + "bbox": [ + 207, + 217, + 404, + 252 + ], + "lines": [ + { + "bbox": [ + 207, + 217, + 404, + 252 + ], + "spans": [ + { + "bbox": [ + 207, + 217, + 404, + 252 + ], + "score": 0.94, + "content": "f _ { k } ( x ) = \\sum _ { i = 1 } ^ { d } \\operatorname* { m a x } ( 0 , 1 - | d x - i | ) \\frac { \\sum _ { j = 1 } ^ { i } | w _ { k j } | } { \\sum _ { m = 1 } ^ { d } | w _ { k m } | }", + "type": "interline_equation", + "image_path": "658f47b9282626a8b3087bedbdc789dc0ff6db78e6d7364432393fe1366f666f.jpg" + } + ] + } + ], + "index": 9.5, + "virtual_lines": [ + { + "bbox": [ + 207, + 217, + 404, + 234.5 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 207, + 234.5, + 404, + 252.0 + ], + "spans": [], + "index": 10 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 259, + 505, + 342 + ], + "lines": [ + { + "bbox": [ + 106, + 261, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 505, + 272 + ], + "score": 1.0, + "content": "In essence, the max term selects the two nearest boundary values of an interval, which are normalized", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 272, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 106, + 272, + 214, + 284 + ], + "score": 1.0, + "content": "cumulative sums over the", + "type": "text" + }, + { + "bbox": [ + 214, + 273, + 228, + 282 + ], + "score": 0.84, + "content": "w _ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 272, + 505, + 284 + ], + "score": 1.0, + "content": "weights, and linearly interpolates between the two. This approach", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "score": 1.0, + "content": "is similar to the subgradient approach by Jaderberg et al. (2015) to make sampling from indices", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 294, + 505, + 305 + ], + "spans": [ + { + "bbox": [ + 106, + 294, + 181, + 305 + ], + "score": 1.0, + "content": "differentiable. All", + "type": "text" + }, + { + "bbox": [ + 181, + 294, + 197, + 304 + ], + "score": 0.88, + "content": "w _ { k i }", + "type": "inline_equation" + }, + { + "bbox": [ + 197, + 294, + 505, + 305 + ], + "score": 1.0, + "content": "are initialized to 1, which makes the functions linear on initialization. When", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 304, + 504, + 317 + ], + "spans": [ + { + "bbox": [ + 106, + 304, + 144, + 317 + ], + "score": 1.0, + "content": "applying", + "type": "text" + }, + { + "bbox": [ + 144, + 304, + 168, + 316 + ], + "score": 0.92, + "content": "f _ { k } ( { \\bf x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 304, + 267, + 317 + ], + "score": 1.0, + "content": "to a vector-valued input", + "type": "text" + }, + { + "bbox": [ + 268, + 307, + 275, + 314 + ], + "score": 0.35, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 275, + 304, + 504, + 317 + ], + "score": 1.0, + "content": ", it is assumed to be applied elementwise. By caching the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 102, + 312, + 508, + 335 + ], + "spans": [ + { + "bbox": [ + 102, + 312, + 223, + 335 + ], + "score": 1.0, + "content": "normalized cumulative sum", + "type": "text" + }, + { + "bbox": [ + 223, + 316, + 313, + 331 + ], + "score": 0.92, + "content": "\\begin{array} { r } { \\sum _ { j } ^ { i } | w _ { k j } | / \\sum _ { m } ^ { d } | w _ { k m } | } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 312, + 508, + 335 + ], + "score": 1.0, + "content": ", this function has linear time complexity with", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 330, + 326, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 330, + 147, + 343 + ], + "score": 1.0, + "content": "respect to", + "type": "text" + }, + { + "bbox": [ + 147, + 330, + 154, + 340 + ], + "score": 0.79, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 154, + 330, + 326, + 343 + ], + "score": 1.0, + "content": "and is efficiently implementable on GPUs.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 346, + 505, + 392 + ], + "lines": [ + { + "bbox": [ + 106, + 347, + 505, + 359 + ], + "spans": [ + { + "bbox": [ + 106, + 347, + 505, + 359 + ], + "score": 1.0, + "content": "Extensions to this are possible through Deep Lattice Networks (You et al., 2017), which preserve", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 358, + 505, + 370 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 469, + 370 + ], + "score": 1.0, + "content": "monotonicity across several nonlinear neural network layers. They would allow A and", + "type": "text" + }, + { + "bbox": [ + 470, + 358, + 480, + 368 + ], + "score": 0.38, + "content": "\\mathbf { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 481, + 358, + 505, + 370 + ], + "score": 1.0, + "content": "to be", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 368, + 505, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 368, + 505, + 382 + ], + "score": 1.0, + "content": "combined in more sophisticated ways beyond an elementwise product, possibly improving counting", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 379, + 494, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 379, + 353, + 393 + ], + "score": 1.0, + "content": "performance as long as the property of the range lying within", + "type": "text" + }, + { + "bbox": [ + 353, + 380, + 374, + 392 + ], + "score": 0.54, + "content": "[ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 379, + 494, + 393 + ], + "score": 1.0, + "content": "is still enforced in some way.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19.5 + }, + { + "type": "title", + "bbox": [ + 108, + 408, + 263, + 421 + ], + "lines": [ + { + "bbox": [ + 105, + 407, + 265, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 407, + 265, + 423 + ], + "score": 1.0, + "content": "B BASELINE ARCHITECTURE", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 433, + 505, + 478 + ], + "lines": [ + { + "bbox": [ + 105, + 432, + 505, + 446 + ], + "spans": [ + { + "bbox": [ + 105, + 432, + 505, + 446 + ], + "score": 1.0, + "content": "This model is based on the work of Kazemi & Elqursh (2017), who outperformed most previous", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 443, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 443, + 505, + 457 + ], + "score": 1.0, + "content": "VQA models on the VQA v1 dataset with a simple baseline architecture. We adapt the model to the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 455, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 505, + 468 + ], + "score": 1.0, + "content": "VQA v2 dataset and make various tweaks that improve validation accuracy slightly. The architecture", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 104, + 465, + 507, + 480 + ], + "spans": [ + { + "bbox": [ + 104, + 465, + 507, + 480 + ], + "score": 1.0, + "content": "is illustrated in Figure 6. Details not mentioned here can be assumed to be the same as in their paper.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 107, + 483, + 505, + 528 + ], + "lines": [ + { + "bbox": [ + 105, + 483, + 505, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 505, + 496 + ], + "score": 1.0, + "content": "The most significant change that we make is the use of object proposal features by Anderson", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 493, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 505, + 507 + ], + "score": 1.0, + "content": "et al. (2017) as previously mentioned. The following tweaks were made without considering the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 506, + 506, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 506, + 518 + ], + "score": 1.0, + "content": "performance impact on the counting component; only the validation accuracy of the baseline was", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 517, + 151, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 151, + 528 + ], + "score": 1.0, + "content": "optimized.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 106, + 533, + 505, + 578 + ], + "lines": [ + { + "bbox": [ + 104, + 532, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 104, + 532, + 201, + 546 + ], + "score": 1.0, + "content": "To fuse vision features", + "type": "text" + }, + { + "bbox": [ + 202, + 535, + 210, + 543 + ], + "score": 0.35, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 532, + 505, + 546 + ], + "score": 1.0, + "content": "and question features y, the baseline concatenates and linearly projects", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 544, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 375, + 556 + ], + "score": 1.0, + "content": "them, followed by a ReLU activation. This is equivalent to ReLU", + "type": "text" + }, + { + "bbox": [ + 375, + 544, + 438, + 556 + ], + "score": 0.64, + "content": "( \\mathbf { W } _ { x } \\mathbf { x } + \\mathbf { W } _ { y } \\mathbf { y } )", + "type": "inline_equation" + }, + { + "bbox": [ + 439, + 545, + 505, + 556 + ], + "score": 1.0, + "content": ". We include an", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 555, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 342, + 568 + ], + "score": 1.0, + "content": "additional term that measures how different the projected", + "type": "text" + }, + { + "bbox": [ + 342, + 557, + 350, + 565 + ], + "score": 0.73, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 555, + 505, + 568 + ], + "score": 1.0, + "content": "is from the projected y, changing the", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 565, + 405, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 191, + 579 + ], + "score": 1.0, + "content": "fusion mechanism to", + "type": "text" + }, + { + "bbox": [ + 192, + 566, + 401, + 579 + ], + "score": 0.84, + "content": "\\mathbf { x } \\odot \\mathbf { y } = \\operatorname { R e L U } ( \\mathbf { W } _ { x } \\mathbf { x } + \\mathbf { W } _ { y } \\mathbf { y } ) - ( \\mathbf { W } _ { x } \\mathbf { x } - \\mathbf { W } _ { y } \\mathbf { y } ) ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 565, + 405, + 579 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 106, + 582, + 505, + 672 + ], + "lines": [ + { + "bbox": [ + 105, + 582, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 506, + 596 + ], + "score": 1.0, + "content": "The LSTM (Hochreiter & Schmidhuber, 1997) for question encoding is replaced with a GRU (Cho", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "et al., 2014) with the same hidden size with dynamic per-example unrolling instead of a fixed 14", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 605, + 506, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 506, + 618 + ], + "score": 1.0, + "content": "words per question. We apply batch normalization (Ioffe & Szegedy, 2015) before the last linear", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 616, + 506, + 628 + ], + "spans": [ + { + "bbox": [ + 104, + 616, + 506, + 628 + ], + "score": 1.0, + "content": "projection in the classifier to the 3000 classes. The learning rate is increased from 0.001 to 0.0015", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "and the batch size is doubled to 256. The model is trained for 100 epochs (1697 iterations per epoch", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 638, + 506, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 506, + 650 + ], + "score": 1.0, + "content": "to train on the training set, 2517 iterations per epoch to train on both training and validation sets)", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "instead of 100,000 iterations, roughly in line with the doubling of dataset size when going from VQA", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 659, + 168, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 168, + 672 + ], + "score": 1.0, + "content": "v1 to VQA v2.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 38.5 + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "Note that this single-model baseline is regularized with dropout (Srivastava et al., 2014), while the", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "other current top models skip this and rely on ensembling to reduce overfitting. This explains why our", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "single-model baseline outperforms most single-model results of the state-of-the-art models. We found", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "ensembling of the regularized baseline to provide a much smaller benefit in preliminary experiments", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 721, + 482, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 482, + 733 + ], + "score": 1.0, + "content": "compared to the results of ensembling unregularized networks reported in Teney et al. (2017).", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 45 + } + ], + "page_idx": 12, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 82, + 349, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 350, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 350, + 96 + ], + "score": 1.0, + "content": "A PIECEWISE LINEAR ACTIVATION FUNCTION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 106, + 505, + 140 + ], + "lines": [ + { + "bbox": [ + 105, + 106, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 106, + 200, + 119 + ], + "score": 1.0, + "content": "Intuitively, the interval", + "type": "text" + }, + { + "bbox": [ + 200, + 106, + 221, + 119 + ], + "score": 0.26, + "content": "[ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 221, + 106, + 269, + 119 + ], + "score": 1.0, + "content": "is split into", + "type": "text" + }, + { + "bbox": [ + 270, + 107, + 276, + 117 + ], + "score": 0.77, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 277, + 106, + 505, + 119 + ], + "score": 1.0, + "content": "equal size intervals. Each contains a line segment that is", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 118, + 505, + 130 + ], + "spans": [ + { + "bbox": [ + 105, + 118, + 505, + 130 + ], + "score": 1.0, + "content": "connected to the neighboring line segments at the boundaries of the intervals. These line segments", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 129, + 272, + 140 + ], + "spans": [ + { + "bbox": [ + 106, + 129, + 272, + 140 + ], + "score": 1.0, + "content": "form the shape of the activation function.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2, + "bbox_fs": [ + 105, + 106, + 505, + 140 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 145, + 505, + 204 + ], + "lines": [ + { + "bbox": [ + 104, + 144, + 506, + 159 + ], + "spans": [ + { + "bbox": [ + 104, + 144, + 182, + 159 + ], + "score": 1.0, + "content": "For each function", + "type": "text" + }, + { + "bbox": [ + 182, + 146, + 192, + 157 + ], + "score": 0.85, + "content": "f _ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 193, + 144, + 235, + 159 + ], + "score": 1.0, + "content": ", there are", + "type": "text" + }, + { + "bbox": [ + 236, + 146, + 242, + 155 + ], + "score": 0.8, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 144, + 279, + 159 + ], + "score": 1.0, + "content": "weights", + "type": "text" + }, + { + "bbox": [ + 279, + 148, + 334, + 157 + ], + "score": 0.86, + "content": "w _ { k 1 } , \\ldots , w _ { k d }", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 144, + 412, + 159 + ], + "score": 1.0, + "content": ", where the weight", + "type": "text" + }, + { + "bbox": [ + 412, + 147, + 428, + 157 + ], + "score": 0.88, + "content": "w _ { k i }", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 144, + 506, + 159 + ], + "score": 1.0, + "content": "is the gradient for", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 103, + 154, + 507, + 172 + ], + "spans": [ + { + "bbox": [ + 103, + 154, + 155, + 172 + ], + "score": 1.0, + "content": "the interval", + "type": "text" + }, + { + "bbox": [ + 155, + 156, + 188, + 169 + ], + "score": 0.91, + "content": "[ \\textstyle { \\frac { i - 1 } { d } } , \\textstyle { \\frac { i } { d } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 154, + 265, + 172 + ], + "score": 1.0, + "content": ". We arbitrarily fix", + "type": "text" + }, + { + "bbox": [ + 265, + 157, + 272, + 167 + ], + "score": 0.8, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 272, + 154, + 507, + 172 + ], + "score": 1.0, + "content": "to be 16 in this paper, observing no significant difference", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 167, + 505, + 181 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 357, + 181 + ], + "score": 1.0, + "content": "when changing it to 8 and 32 in preliminary experiments. All", + "type": "text" + }, + { + "bbox": [ + 357, + 169, + 373, + 179 + ], + "score": 0.86, + "content": "w _ { k i }", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 167, + 505, + 181 + ], + "score": 1.0, + "content": "are enforced to be non-negative", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 179, + 505, + 191 + ], + "spans": [ + { + "bbox": [ + 106, + 179, + 505, + 191 + ], + "score": 1.0, + "content": "by always using the absolute value of them, which yields the monotonicity property. Dividing the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 189, + 461, + 205 + ], + "spans": [ + { + "bbox": [ + 104, + 191, + 152, + 205 + ], + "score": 1.0, + "content": "weights by", + "type": "text" + }, + { + "bbox": [ + 152, + 189, + 198, + 204 + ], + "score": 0.93, + "content": "\\Sigma _ { m } ^ { d } \\mid w _ { k m } \\mid", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 191, + 294, + 205 + ], + "score": 1.0, + "content": "yields the property that", + "type": "text" + }, + { + "bbox": [ + 294, + 191, + 332, + 204 + ], + "score": 0.93, + "content": "f ( 1 ) = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 332, + 191, + 461, + 205 + ], + "score": 1.0, + "content": ". The function can be written as", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6, + "bbox_fs": [ + 103, + 144, + 507, + 205 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 207, + 217, + 404, + 252 + ], + "lines": [ + { + "bbox": [ + 207, + 217, + 404, + 252 + ], + "spans": [ + { + "bbox": [ + 207, + 217, + 404, + 252 + ], + "score": 0.94, + "content": "f _ { k } ( x ) = \\sum _ { i = 1 } ^ { d } \\operatorname* { m a x } ( 0 , 1 - | d x - i | ) \\frac { \\sum _ { j = 1 } ^ { i } | w _ { k j } | } { \\sum _ { m = 1 } ^ { d } | w _ { k m } | }", + "type": "interline_equation", + "image_path": "658f47b9282626a8b3087bedbdc789dc0ff6db78e6d7364432393fe1366f666f.jpg" + } + ] + } + ], + "index": 9.5, + "virtual_lines": [ + { + "bbox": [ + 207, + 217, + 404, + 234.5 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 207, + 234.5, + 404, + 252.0 + ], + "spans": [], + "index": 10 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 259, + 505, + 342 + ], + "lines": [ + { + "bbox": [ + 106, + 261, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 505, + 272 + ], + "score": 1.0, + "content": "In essence, the max term selects the two nearest boundary values of an interval, which are normalized", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 272, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 106, + 272, + 214, + 284 + ], + "score": 1.0, + "content": "cumulative sums over the", + "type": "text" + }, + { + "bbox": [ + 214, + 273, + 228, + 282 + ], + "score": 0.84, + "content": "w _ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 272, + 505, + 284 + ], + "score": 1.0, + "content": "weights, and linearly interpolates between the two. This approach", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "score": 1.0, + "content": "is similar to the subgradient approach by Jaderberg et al. (2015) to make sampling from indices", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 294, + 505, + 305 + ], + "spans": [ + { + "bbox": [ + 106, + 294, + 181, + 305 + ], + "score": 1.0, + "content": "differentiable. All", + "type": "text" + }, + { + "bbox": [ + 181, + 294, + 197, + 304 + ], + "score": 0.88, + "content": "w _ { k i }", + "type": "inline_equation" + }, + { + "bbox": [ + 197, + 294, + 505, + 305 + ], + "score": 1.0, + "content": "are initialized to 1, which makes the functions linear on initialization. When", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 304, + 504, + 317 + ], + "spans": [ + { + "bbox": [ + 106, + 304, + 144, + 317 + ], + "score": 1.0, + "content": "applying", + "type": "text" + }, + { + "bbox": [ + 144, + 304, + 168, + 316 + ], + "score": 0.92, + "content": "f _ { k } ( { \\bf x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 304, + 267, + 317 + ], + "score": 1.0, + "content": "to a vector-valued input", + "type": "text" + }, + { + "bbox": [ + 268, + 307, + 275, + 314 + ], + "score": 0.35, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 275, + 304, + 504, + 317 + ], + "score": 1.0, + "content": ", it is assumed to be applied elementwise. By caching the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 102, + 312, + 508, + 335 + ], + "spans": [ + { + "bbox": [ + 102, + 312, + 223, + 335 + ], + "score": 1.0, + "content": "normalized cumulative sum", + "type": "text" + }, + { + "bbox": [ + 223, + 316, + 313, + 331 + ], + "score": 0.92, + "content": "\\begin{array} { r } { \\sum _ { j } ^ { i } | w _ { k j } | / \\sum _ { m } ^ { d } | w _ { k m } | } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 312, + 508, + 335 + ], + "score": 1.0, + "content": ", this function has linear time complexity with", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 330, + 326, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 330, + 147, + 343 + ], + "score": 1.0, + "content": "respect to", + "type": "text" + }, + { + "bbox": [ + 147, + 330, + 154, + 340 + ], + "score": 0.79, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 154, + 330, + 326, + 343 + ], + "score": 1.0, + "content": "and is efficiently implementable on GPUs.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14, + "bbox_fs": [ + 102, + 261, + 508, + 343 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 346, + 505, + 392 + ], + "lines": [ + { + "bbox": [ + 106, + 347, + 505, + 359 + ], + "spans": [ + { + "bbox": [ + 106, + 347, + 505, + 359 + ], + "score": 1.0, + "content": "Extensions to this are possible through Deep Lattice Networks (You et al., 2017), which preserve", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 358, + 505, + 370 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 469, + 370 + ], + "score": 1.0, + "content": "monotonicity across several nonlinear neural network layers. They would allow A and", + "type": "text" + }, + { + "bbox": [ + 470, + 358, + 480, + 368 + ], + "score": 0.38, + "content": "\\mathbf { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 481, + 358, + 505, + 370 + ], + "score": 1.0, + "content": "to be", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 368, + 505, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 368, + 505, + 382 + ], + "score": 1.0, + "content": "combined in more sophisticated ways beyond an elementwise product, possibly improving counting", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 379, + 494, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 379, + 353, + 393 + ], + "score": 1.0, + "content": "performance as long as the property of the range lying within", + "type": "text" + }, + { + "bbox": [ + 353, + 380, + 374, + 392 + ], + "score": 0.54, + "content": "[ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 379, + 494, + 393 + ], + "score": 1.0, + "content": "is still enforced in some way.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 347, + 505, + 393 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 408, + 263, + 421 + ], + "lines": [ + { + "bbox": [ + 105, + 407, + 265, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 407, + 265, + 423 + ], + "score": 1.0, + "content": "B BASELINE ARCHITECTURE", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 433, + 505, + 478 + ], + "lines": [ + { + "bbox": [ + 105, + 432, + 505, + 446 + ], + "spans": [ + { + "bbox": [ + 105, + 432, + 505, + 446 + ], + "score": 1.0, + "content": "This model is based on the work of Kazemi & Elqursh (2017), who outperformed most previous", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 443, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 443, + 505, + 457 + ], + "score": 1.0, + "content": "VQA models on the VQA v1 dataset with a simple baseline architecture. We adapt the model to the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 455, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 505, + 468 + ], + "score": 1.0, + "content": "VQA v2 dataset and make various tweaks that improve validation accuracy slightly. The architecture", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 104, + 465, + 507, + 480 + ], + "spans": [ + { + "bbox": [ + 104, + 465, + 507, + 480 + ], + "score": 1.0, + "content": "is illustrated in Figure 6. Details not mentioned here can be assumed to be the same as in their paper.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 24.5, + "bbox_fs": [ + 104, + 432, + 507, + 480 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 483, + 505, + 528 + ], + "lines": [ + { + "bbox": [ + 105, + 483, + 505, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 505, + 496 + ], + "score": 1.0, + "content": "The most significant change that we make is the use of object proposal features by Anderson", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 493, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 505, + 507 + ], + "score": 1.0, + "content": "et al. (2017) as previously mentioned. The following tweaks were made without considering the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 506, + 506, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 506, + 518 + ], + "score": 1.0, + "content": "performance impact on the counting component; only the validation accuracy of the baseline was", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 517, + 151, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 151, + 528 + ], + "score": 1.0, + "content": "optimized.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28.5, + "bbox_fs": [ + 105, + 483, + 506, + 528 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 533, + 505, + 578 + ], + "lines": [ + { + "bbox": [ + 104, + 532, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 104, + 532, + 201, + 546 + ], + "score": 1.0, + "content": "To fuse vision features", + "type": "text" + }, + { + "bbox": [ + 202, + 535, + 210, + 543 + ], + "score": 0.35, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 532, + 505, + 546 + ], + "score": 1.0, + "content": "and question features y, the baseline concatenates and linearly projects", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 544, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 375, + 556 + ], + "score": 1.0, + "content": "them, followed by a ReLU activation. This is equivalent to ReLU", + "type": "text" + }, + { + "bbox": [ + 375, + 544, + 438, + 556 + ], + "score": 0.64, + "content": "( \\mathbf { W } _ { x } \\mathbf { x } + \\mathbf { W } _ { y } \\mathbf { y } )", + "type": "inline_equation" + }, + { + "bbox": [ + 439, + 545, + 505, + 556 + ], + "score": 1.0, + "content": ". We include an", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 555, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 342, + 568 + ], + "score": 1.0, + "content": "additional term that measures how different the projected", + "type": "text" + }, + { + "bbox": [ + 342, + 557, + 350, + 565 + ], + "score": 0.73, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 555, + 505, + 568 + ], + "score": 1.0, + "content": "is from the projected y, changing the", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 565, + 405, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 191, + 579 + ], + "score": 1.0, + "content": "fusion mechanism to", + "type": "text" + }, + { + "bbox": [ + 192, + 566, + 401, + 579 + ], + "score": 0.84, + "content": "\\mathbf { x } \\odot \\mathbf { y } = \\operatorname { R e L U } ( \\mathbf { W } _ { x } \\mathbf { x } + \\mathbf { W } _ { y } \\mathbf { y } ) - ( \\mathbf { W } _ { x } \\mathbf { x } - \\mathbf { W } _ { y } \\mathbf { y } ) ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 565, + 405, + 579 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5, + "bbox_fs": [ + 104, + 532, + 505, + 579 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 582, + 505, + 672 + ], + "lines": [ + { + "bbox": [ + 105, + 582, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 506, + 596 + ], + "score": 1.0, + "content": "The LSTM (Hochreiter & Schmidhuber, 1997) for question encoding is replaced with a GRU (Cho", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "et al., 2014) with the same hidden size with dynamic per-example unrolling instead of a fixed 14", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 605, + 506, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 506, + 618 + ], + "score": 1.0, + "content": "words per question. We apply batch normalization (Ioffe & Szegedy, 2015) before the last linear", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 616, + 506, + 628 + ], + "spans": [ + { + "bbox": [ + 104, + 616, + 506, + 628 + ], + "score": 1.0, + "content": "projection in the classifier to the 3000 classes. The learning rate is increased from 0.001 to 0.0015", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "and the batch size is doubled to 256. The model is trained for 100 epochs (1697 iterations per epoch", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 638, + 506, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 506, + 650 + ], + "score": 1.0, + "content": "to train on the training set, 2517 iterations per epoch to train on both training and validation sets)", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "instead of 100,000 iterations, roughly in line with the doubling of dataset size when going from VQA", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 659, + 168, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 168, + 672 + ], + "score": 1.0, + "content": "v1 to VQA v2.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 38.5, + "bbox_fs": [ + 104, + 582, + 506, + 672 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "Note that this single-model baseline is regularized with dropout (Srivastava et al., 2014), while the", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "other current top models skip this and rely on ensembling to reduce overfitting. This explains why our", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "single-model baseline outperforms most single-model results of the state-of-the-art models. We found", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "ensembling of the regularized baseline to provide a much smaller benefit in preliminary experiments", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 721, + 482, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 482, + 733 + ], + "score": 1.0, + "content": "compared to the results of ensembling unregularized networks reported in Teney et al. (2017).", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 45, + "bbox_fs": [ + 105, + 677, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 115, + 84, + 495, + 237 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 115, + 84, + 495, + 237 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 115, + 84, + 495, + 237 + ], + "spans": [ + { + "bbox": [ + 115, + 84, + 495, + 237 + ], + "score": 0.97, + "type": "image", + "image_path": "490c1f6c072e0a062d39ff4d6cc97980d0cf6261d8fcaf1d9d6a6f9cad6001a1.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 115, + 84, + 495, + 135.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 115, + 135.0, + 495, + 186.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 115, + 186.0, + 495, + 237.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 251, + 506, + 362 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 252, + 506, + 264 + ], + "spans": [ + { + "bbox": [ + 105, + 252, + 506, + 264 + ], + "score": 1.0, + "content": "Figure 6: Schematic view of a model using our counting component. The modifications made to", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 263, + 505, + 275 + ], + "spans": [ + { + "bbox": [ + 106, + 263, + 505, + 275 + ], + "score": 1.0, + "content": "the baseline model when including the counting component are marked in red. Blue blocks mark", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 273, + 507, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 507, + 286 + ], + "score": 1.0, + "content": "components with trainable parameters, gray blocks mark components without trainable parameters.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 283, + 506, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 283, + 132, + 298 + ], + "score": 1.0, + "content": "White", + "type": "text" + }, + { + "bbox": [ + 132, + 285, + 143, + 296 + ], + "score": 0.87, + "content": "\\textsuperscript { \\textregistered }", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 283, + 506, + 298 + ], + "score": 1.0, + "content": "mark linear layers, either linear projections or convolutions with a spatial size of 1 depending", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 294, + 506, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 461, + 309 + ], + "score": 1.0, + "content": "on the context. Dropout with drop probability 0.5 is applied before the GRU and every", + "type": "text" + }, + { + "bbox": [ + 461, + 296, + 472, + 307 + ], + "score": 0.86, + "content": "\\textsuperscript { \\textregistered }", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 294, + 506, + 309 + ], + "score": 1.0, + "content": ", except", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 305, + 506, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 305, + 147, + 320 + ], + "score": 1.0, + "content": "before the", + "type": "text" + }, + { + "bbox": [ + 148, + 307, + 159, + 318 + ], + "score": 0.86, + "content": "\\textsuperscript { \\textregistered }", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 305, + 278, + 320 + ], + "score": 1.0, + "content": "after the counting component.", + "type": "text" + }, + { + "bbox": [ + 279, + 307, + 288, + 317 + ], + "score": 0.8, + "content": "\\diamond", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 305, + 506, + 320 + ], + "score": 1.0, + "content": "stands for the fusion function we define in Appendix B,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 318, + 506, + 329 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 247, + 329 + ], + "score": 1.0, + "content": "BN stands for batch normalization,", + "type": "text" + }, + { + "bbox": [ + 248, + 320, + 255, + 327 + ], + "score": 0.73, + "content": "\\sigma", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 318, + 506, + 329 + ], + "score": 1.0, + "content": "stands for a logistic, and Embedding is a word embedding that", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 329, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 505, + 340 + ], + "score": 1.0, + "content": "has been fed through a tanh function. The two glimpses of the attention mechanism are represented", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 339, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 230, + 353 + ], + "score": 1.0, + "content": "with the two lines exiting the", + "type": "text" + }, + { + "bbox": [ + 230, + 340, + 241, + 351 + ], + "score": 0.86, + "content": "\\textsuperscript { \\textregistered }", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 339, + 505, + 353 + ], + "score": 1.0, + "content": ". Note that one of the two glimpses is shared with the counting", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 104, + 351, + 156, + 363 + ], + "spans": [ + { + "bbox": [ + 104, + 351, + 156, + 363 + ], + "score": 1.0, + "content": "component.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 7.5 + } + ], + "index": 4.25 + }, + { + "type": "image", + "bbox": [ + 113, + 472, + 506, + 690 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 113, + 472, + 506, + 690 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 113, + 472, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 113, + 472, + 506, + 690 + ], + "score": 0.976, + "type": "image", + "image_path": "07d2e4d6eedacaf38bf7ab5fb51fab2d11a25b373c83069db69f688b7b40cae0.jpg" + } + ] + } + ], + "index": 14, + "virtual_lines": [ + { + "bbox": [ + 113, + 472, + 506, + 544.6666666666666 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 113, + 544.6666666666666, + 506, + 617.3333333333333 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 113, + 617.3333333333333, + 506, + 689.9999999999999 + ], + "spans": [], + "index": 15 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 703, + 505, + 736 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 703, + 504, + 715 + ], + "spans": [ + { + "bbox": [ + 106, + 703, + 274, + 715 + ], + "score": 1.0, + "content": "Figure 7: Shape of activation functions as", + "type": "text" + }, + { + "bbox": [ + 274, + 704, + 279, + 713 + ], + "score": 0.73, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 703, + 330, + 715 + ], + "score": 1.0, + "content": "is varied for", + "type": "text" + }, + { + "bbox": [ + 330, + 704, + 362, + 715 + ], + "score": 0.91, + "content": "q = 0 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 703, + 504, + 715 + ], + "score": 1.0, + "content": "on the toy dataset. Each line shows", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 714, + 505, + 727 + ], + "spans": [ + { + "bbox": [ + 105, + 714, + 274, + 727 + ], + "score": 1.0, + "content": "the shape of the activation function when", + "type": "text" + }, + { + "bbox": [ + 274, + 715, + 279, + 724 + ], + "score": 0.7, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 714, + 505, + 727 + ], + "score": 1.0, + "content": "is set to the value associated to its color. Best viewed in", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 724, + 133, + 739 + ], + "spans": [ + { + "bbox": [ + 105, + 724, + 133, + 739 + ], + "score": 1.0, + "content": "color.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17 + } + ], + "index": 15.5 + } + ], + "page_idx": 13, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 106, + 421, + 334, + 433 + ], + "lines": [ + { + "bbox": [ + 106, + 419, + 335, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 419, + 335, + 435 + ], + "score": 1.0, + "content": "C FULL PLOTS OF ACTIVATION FUNCTIONS", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 115, + 84, + 495, + 237 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 115, + 84, + 495, + 237 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 115, + 84, + 495, + 237 + ], + "spans": [ + { + "bbox": [ + 115, + 84, + 495, + 237 + ], + "score": 0.97, + "type": "image", + "image_path": "490c1f6c072e0a062d39ff4d6cc97980d0cf6261d8fcaf1d9d6a6f9cad6001a1.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 115, + 84, + 495, + 135.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 115, + 135.0, + 495, + 186.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 115, + 186.0, + 495, + 237.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 251, + 506, + 362 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 252, + 506, + 264 + ], + "spans": [ + { + "bbox": [ + 105, + 252, + 506, + 264 + ], + "score": 1.0, + "content": "Figure 6: Schematic view of a model using our counting component. The modifications made to", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 263, + 505, + 275 + ], + "spans": [ + { + "bbox": [ + 106, + 263, + 505, + 275 + ], + "score": 1.0, + "content": "the baseline model when including the counting component are marked in red. Blue blocks mark", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 273, + 507, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 507, + 286 + ], + "score": 1.0, + "content": "components with trainable parameters, gray blocks mark components without trainable parameters.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 283, + 506, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 283, + 132, + 298 + ], + "score": 1.0, + "content": "White", + "type": "text" + }, + { + "bbox": [ + 132, + 285, + 143, + 296 + ], + "score": 0.87, + "content": "\\textsuperscript { \\textregistered }", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 283, + 506, + 298 + ], + "score": 1.0, + "content": "mark linear layers, either linear projections or convolutions with a spatial size of 1 depending", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 294, + 506, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 461, + 309 + ], + "score": 1.0, + "content": "on the context. Dropout with drop probability 0.5 is applied before the GRU and every", + "type": "text" + }, + { + "bbox": [ + 461, + 296, + 472, + 307 + ], + "score": 0.86, + "content": "\\textsuperscript { \\textregistered }", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 294, + 506, + 309 + ], + "score": 1.0, + "content": ", except", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 305, + 506, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 305, + 147, + 320 + ], + "score": 1.0, + "content": "before the", + "type": "text" + }, + { + "bbox": [ + 148, + 307, + 159, + 318 + ], + "score": 0.86, + "content": "\\textsuperscript { \\textregistered }", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 305, + 278, + 320 + ], + "score": 1.0, + "content": "after the counting component.", + "type": "text" + }, + { + "bbox": [ + 279, + 307, + 288, + 317 + ], + "score": 0.8, + "content": "\\diamond", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 305, + 506, + 320 + ], + "score": 1.0, + "content": "stands for the fusion function we define in Appendix B,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 318, + 506, + 329 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 247, + 329 + ], + "score": 1.0, + "content": "BN stands for batch normalization,", + "type": "text" + }, + { + "bbox": [ + 248, + 320, + 255, + 327 + ], + "score": 0.73, + "content": "\\sigma", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 318, + 506, + 329 + ], + "score": 1.0, + "content": "stands for a logistic, and Embedding is a word embedding that", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 329, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 505, + 340 + ], + "score": 1.0, + "content": "has been fed through a tanh function. The two glimpses of the attention mechanism are represented", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 339, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 230, + 353 + ], + "score": 1.0, + "content": "with the two lines exiting the", + "type": "text" + }, + { + "bbox": [ + 230, + 340, + 241, + 351 + ], + "score": 0.86, + "content": "\\textsuperscript { \\textregistered }", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 339, + 505, + 353 + ], + "score": 1.0, + "content": ". Note that one of the two glimpses is shared with the counting", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 104, + 351, + 156, + 363 + ], + "spans": [ + { + "bbox": [ + 104, + 351, + 156, + 363 + ], + "score": 1.0, + "content": "component.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 7.5 + } + ], + "index": 4.25 + }, + { + "type": "image", + "bbox": [ + 113, + 472, + 506, + 690 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 113, + 472, + 506, + 690 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 113, + 472, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 113, + 472, + 506, + 690 + ], + "score": 0.976, + "type": "image", + "image_path": "07d2e4d6eedacaf38bf7ab5fb51fab2d11a25b373c83069db69f688b7b40cae0.jpg" + } + ] + } + ], + "index": 14, + "virtual_lines": [ + { + "bbox": [ + 113, + 472, + 506, + 544.6666666666666 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 113, + 544.6666666666666, + 506, + 617.3333333333333 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 113, + 617.3333333333333, + 506, + 689.9999999999999 + ], + "spans": [], + "index": 15 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 703, + 505, + 736 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 703, + 504, + 715 + ], + "spans": [ + { + "bbox": [ + 106, + 703, + 274, + 715 + ], + "score": 1.0, + "content": "Figure 7: Shape of activation functions as", + "type": "text" + }, + { + "bbox": [ + 274, + 704, + 279, + 713 + ], + "score": 0.73, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 703, + 330, + 715 + ], + "score": 1.0, + "content": "is varied for", + "type": "text" + }, + { + "bbox": [ + 330, + 704, + 362, + 715 + ], + "score": 0.91, + "content": "q = 0 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 703, + 504, + 715 + ], + "score": 1.0, + "content": "on the toy dataset. Each line shows", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 714, + 505, + 727 + ], + "spans": [ + { + "bbox": [ + 105, + 714, + 274, + 727 + ], + "score": 1.0, + "content": "the shape of the activation function when", + "type": "text" + }, + { + "bbox": [ + 274, + 715, + 279, + 724 + ], + "score": 0.7, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 714, + 505, + 727 + ], + "score": 1.0, + "content": "is set to the value associated to its color. Best viewed in", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 724, + 133, + 739 + ], + "spans": [ + { + "bbox": [ + 105, + 724, + 133, + 739 + ], + "score": 1.0, + "content": "color.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17 + } + ], + "index": 15.5 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 113, + 109, + 506, + 327 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 113, + 109, + 506, + 327 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 113, + 109, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 113, + 109, + 506, + 327 + ], + "score": 0.975, + "type": "image", + "image_path": "e630ceffcd3a5654e3eb6233016450532e537c9e33e24a644459ee0f3beb38ae.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 113, + 109, + 506, + 181.66666666666669 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 113, + 181.66666666666669, + 506, + 254.33333333333337 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 113, + 254.33333333333337, + 506, + 327.00000000000006 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 342, + 505, + 375 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 342, + 505, + 354 + ], + "spans": [ + { + "bbox": [ + 106, + 342, + 274, + 354 + ], + "score": 1.0, + "content": "Figure 8: Shape of activation functions as", + "type": "text" + }, + { + "bbox": [ + 274, + 344, + 280, + 354 + ], + "score": 0.82, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 281, + 342, + 331, + 354 + ], + "score": 1.0, + "content": "is varied for", + "type": "text" + }, + { + "bbox": [ + 331, + 342, + 362, + 353 + ], + "score": 0.9, + "content": "l = 0 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 342, + 505, + 354 + ], + "score": 1.0, + "content": "on the toy dataset. Each line shows", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 353, + 505, + 365 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 273, + 365 + ], + "score": 1.0, + "content": "the shape of the activation function when", + "type": "text" + }, + { + "bbox": [ + 273, + 355, + 280, + 365 + ], + "score": 0.8, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 353, + 505, + 365 + ], + "score": 1.0, + "content": "is set to the value associated to its color. Best viewed in", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 362, + 133, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 133, + 377 + ], + "score": 1.0, + "content": "color.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "image", + "bbox": [ + 113, + 438, + 501, + 655 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 113, + 438, + 501, + 655 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 113, + 438, + 501, + 655 + ], + "spans": [ + { + "bbox": [ + 113, + 438, + 501, + 655 + ], + "score": 0.973, + "type": "image", + "image_path": "0c0fbd90d5fdb814b3a5f433d4b3e097fa2287a734697d8678539536c723c7d2.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 113, + 438, + 501, + 510.3333333333333 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 113, + 510.3333333333333, + 501, + 582.6666666666666 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 113, + 582.6666666666666, + 501, + 655.0 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 669, + 505, + 703 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 668, + 506, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 506, + 681 + ], + "score": 1.0, + "content": "Figure 9: Shape of activation functions for a model trained on the train and validation sets of VQA", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 679, + 506, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 679, + 452, + 693 + ], + "score": 1.0, + "content": "v2 (thick black), compared against the shapes when parametrizing the toy dataset with", + "type": "text" + }, + { + "bbox": [ + 453, + 682, + 459, + 691 + ], + "score": 0.77, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 459, + 679, + 506, + 693 + ], + "score": 1.0, + "content": "around 0.4", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 691, + 405, + 703 + ], + "spans": [ + { + "bbox": [ + 106, + 691, + 283, + 703 + ], + "score": 1.0, + "content": "(green), 0.7 (orange), or 1.0 (red) with fixed", + "type": "text" + }, + { + "bbox": [ + 284, + 691, + 314, + 701 + ], + "score": 0.89, + "content": "l = 0 . 2", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 691, + 405, + 703 + ], + "score": 1.0, + "content": ". Best viewed in color.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + } + ], + "index": 8.5 + } + ], + "page_idx": 14, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 113, + 109, + 506, + 327 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 113, + 109, + 506, + 327 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 113, + 109, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 113, + 109, + 506, + 327 + ], + "score": 0.975, + "type": "image", + "image_path": "e630ceffcd3a5654e3eb6233016450532e537c9e33e24a644459ee0f3beb38ae.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 113, + 109, + 506, + 181.66666666666669 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 113, + 181.66666666666669, + 506, + 254.33333333333337 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 113, + 254.33333333333337, + 506, + 327.00000000000006 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 342, + 505, + 375 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 342, + 505, + 354 + ], + "spans": [ + { + "bbox": [ + 106, + 342, + 274, + 354 + ], + "score": 1.0, + "content": "Figure 8: Shape of activation functions as", + "type": "text" + }, + { + "bbox": [ + 274, + 344, + 280, + 354 + ], + "score": 0.82, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 281, + 342, + 331, + 354 + ], + "score": 1.0, + "content": "is varied for", + "type": "text" + }, + { + "bbox": [ + 331, + 342, + 362, + 353 + ], + "score": 0.9, + "content": "l = 0 . 5", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 342, + 505, + 354 + ], + "score": 1.0, + "content": "on the toy dataset. Each line shows", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 353, + 505, + 365 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 273, + 365 + ], + "score": 1.0, + "content": "the shape of the activation function when", + "type": "text" + }, + { + "bbox": [ + 273, + 355, + 280, + 365 + ], + "score": 0.8, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 353, + 505, + 365 + ], + "score": 1.0, + "content": "is set to the value associated to its color. Best viewed in", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 362, + 133, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 133, + 377 + ], + "score": 1.0, + "content": "color.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "image", + "bbox": [ + 113, + 438, + 501, + 655 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 113, + 438, + 501, + 655 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 113, + 438, + 501, + 655 + ], + "spans": [ + { + "bbox": [ + 113, + 438, + 501, + 655 + ], + "score": 0.973, + "type": "image", + "image_path": "0c0fbd90d5fdb814b3a5f433d4b3e097fa2287a734697d8678539536c723c7d2.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 113, + 438, + 501, + 510.3333333333333 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 113, + 510.3333333333333, + 501, + 582.6666666666666 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 113, + 582.6666666666666, + 501, + 655.0 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 669, + 505, + 703 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 668, + 506, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 506, + 681 + ], + "score": 1.0, + "content": "Figure 9: Shape of activation functions for a model trained on the train and validation sets of VQA", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 679, + 506, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 679, + 452, + 693 + ], + "score": 1.0, + "content": "v2 (thick black), compared against the shapes when parametrizing the toy dataset with", + "type": "text" + }, + { + "bbox": [ + 453, + 682, + 459, + 691 + ], + "score": 0.77, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 459, + 679, + 506, + 693 + ], + "score": 1.0, + "content": "around 0.4", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 691, + 405, + 703 + ], + "spans": [ + { + "bbox": [ + 106, + 691, + 283, + 703 + ], + "score": 1.0, + "content": "(green), 0.7 (orange), or 1.0 (red) with fixed", + "type": "text" + }, + { + "bbox": [ + 284, + 691, + 314, + 701 + ], + "score": 0.89, + "content": "l = 0 . 2", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 691, + 405, + 703 + ], + "score": 1.0, + "content": ". Best viewed in color.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + } + ], + "index": 8.5 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 132, + 113, + 469, + 624 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 132, + 113, + 469, + 624 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 132, + 113, + 469, + 624 + ], + "spans": [ + { + "bbox": [ + 132, + 113, + 469, + 624 + ], + "score": 0.976, + "type": "image", + "image_path": "82a95f366fb3f29067d4526bec9b7457d9cdecee732615090ede2cab04ee24a8.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 132, + 113, + 469, + 283.33333333333337 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 132, + 283.33333333333337, + 469, + 453.66666666666674 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 132, + 453.66666666666674, + 469, + 624.0000000000001 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 635, + 505, + 735 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 635, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 425, + 649 + ], + "score": 1.0, + "content": "Figure 10: Example toy dataset data for varying bounding box side lengths", + "type": "text" + }, + { + "bbox": [ + 425, + 636, + 430, + 646 + ], + "score": 0.7, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 431, + 635, + 474, + 649 + ], + "score": 1.0, + "content": "and noise", + "type": "text" + }, + { + "bbox": [ + 474, + 638, + 480, + 648 + ], + "score": 0.71, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 481, + 635, + 505, + 649 + ], + "score": 1.0, + "content": ". The", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 646, + 506, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 506, + 660 + ], + "score": 1.0, + "content": "ground truth column shows bounding boxes of randomly placed true objects (blue) and of irrelevant", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 658, + 505, + 670 + ], + "spans": [ + { + "bbox": [ + 106, + 658, + 505, + 670 + ], + "score": 1.0, + "content": "objects (red). The data column visualizes the samples that are actually used as input (dark blues", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 668, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 505, + 681 + ], + "score": 1.0, + "content": "represent weights close to 1, dark reds represent weights close to 0, lighter colors represent weights", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 678, + 506, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 304, + 693 + ], + "score": 1.0, + "content": "closer to 0.5). The weight of the ith bounding box", + "type": "text" + }, + { + "bbox": [ + 304, + 680, + 313, + 691 + ], + "score": 0.87, + "content": "b _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 678, + 366, + 693 + ], + "score": 1.0, + "content": "is defined as", + "type": "text" + }, + { + "bbox": [ + 366, + 680, + 417, + 691 + ], + "score": 0.89, + "content": "a _ { i } = ( 1 - q )", + "type": "inline_equation" + }, + { + "bbox": [ + 418, + 678, + 442, + 693 + ], + "score": 1.0, + "content": "score", + "type": "text" + }, + { + "bbox": [ + 442, + 680, + 463, + 691 + ], + "score": 0.82, + "content": "+ q z", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 678, + 506, + 693 + ], + "score": 1.0, + "content": "where the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 689, + 506, + 705 + ], + "spans": [ + { + "bbox": [ + 104, + 689, + 243, + 705 + ], + "score": 1.0, + "content": "score is the maximum overlap of", + "type": "text" + }, + { + "bbox": [ + 243, + 691, + 251, + 702 + ], + "score": 0.87, + "content": "b _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 251, + 689, + 506, + 705 + ], + "score": 1.0, + "content": "with any true bounding box or 0 if there are no true bounding", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 702, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 106, + 702, + 148, + 713 + ], + "score": 1.0, + "content": "boxes and", + "type": "text" + }, + { + "bbox": [ + 149, + 703, + 155, + 711 + ], + "score": 0.75, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 702, + 214, + 713 + ], + "score": 1.0, + "content": "is drawn from", + "type": "text" + }, + { + "bbox": [ + 214, + 702, + 245, + 713 + ], + "score": 0.91, + "content": "U ( 0 , 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 702, + 506, + 713 + ], + "score": 1.0, + "content": ". Note how this turns red bounding boxes that overlap a lot with a", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 713, + 505, + 724 + ], + "spans": [ + { + "bbox": [ + 106, + 713, + 505, + 724 + ], + "score": 1.0, + "content": "blue bounding box in the ground truth column into a blue bounding box in the data column, which", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 723, + 428, + 735 + ], + "spans": [ + { + "bbox": [ + 105, + 723, + 428, + 735 + ], + "score": 1.0, + "content": "simulates the duplicate proposal that we have to deal with. Best viewed in color.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 7 + } + ], + "index": 4.0 + } + ], + "page_idx": 15, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "16", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 82, + 281, + 93 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 282, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 282, + 95 + ], + "score": 1.0, + "content": "D EXAMPLE TOY DATASET DATA", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 132, + 113, + 469, + 624 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 132, + 113, + 469, + 624 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 132, + 113, + 469, + 624 + ], + "spans": [ + { + "bbox": [ + 132, + 113, + 469, + 624 + ], + "score": 0.976, + "type": "image", + "image_path": "82a95f366fb3f29067d4526bec9b7457d9cdecee732615090ede2cab04ee24a8.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 132, + 113, + 469, + 283.33333333333337 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 132, + 283.33333333333337, + 469, + 453.66666666666674 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 132, + 453.66666666666674, + 469, + 624.0000000000001 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 635, + 505, + 735 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 635, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 425, + 649 + ], + "score": 1.0, + "content": "Figure 10: Example toy dataset data for varying bounding box side lengths", + "type": "text" + }, + { + "bbox": [ + 425, + 636, + 430, + 646 + ], + "score": 0.7, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 431, + 635, + 474, + 649 + ], + "score": 1.0, + "content": "and noise", + "type": "text" + }, + { + "bbox": [ + 474, + 638, + 480, + 648 + ], + "score": 0.71, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 481, + 635, + 505, + 649 + ], + "score": 1.0, + "content": ". The", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 646, + 506, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 506, + 660 + ], + "score": 1.0, + "content": "ground truth column shows bounding boxes of randomly placed true objects (blue) and of irrelevant", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 658, + 505, + 670 + ], + "spans": [ + { + "bbox": [ + 106, + 658, + 505, + 670 + ], + "score": 1.0, + "content": "objects (red). The data column visualizes the samples that are actually used as input (dark blues", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 668, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 505, + 681 + ], + "score": 1.0, + "content": "represent weights close to 1, dark reds represent weights close to 0, lighter colors represent weights", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 678, + 506, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 304, + 693 + ], + "score": 1.0, + "content": "closer to 0.5). The weight of the ith bounding box", + "type": "text" + }, + { + "bbox": [ + 304, + 680, + 313, + 691 + ], + "score": 0.87, + "content": "b _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 678, + 366, + 693 + ], + "score": 1.0, + "content": "is defined as", + "type": "text" + }, + { + "bbox": [ + 366, + 680, + 417, + 691 + ], + "score": 0.89, + "content": "a _ { i } = ( 1 - q )", + "type": "inline_equation" + }, + { + "bbox": [ + 418, + 678, + 442, + 693 + ], + "score": 1.0, + "content": "score", + "type": "text" + }, + { + "bbox": [ + 442, + 680, + 463, + 691 + ], + "score": 0.82, + "content": "+ q z", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 678, + 506, + 693 + ], + "score": 1.0, + "content": "where the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 689, + 506, + 705 + ], + "spans": [ + { + "bbox": [ + 104, + 689, + 243, + 705 + ], + "score": 1.0, + "content": "score is the maximum overlap of", + "type": "text" + }, + { + "bbox": [ + 243, + 691, + 251, + 702 + ], + "score": 0.87, + "content": "b _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 251, + 689, + 506, + 705 + ], + "score": 1.0, + "content": "with any true bounding box or 0 if there are no true bounding", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 702, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 106, + 702, + 148, + 713 + ], + "score": 1.0, + "content": "boxes and", + "type": "text" + }, + { + "bbox": [ + 149, + 703, + 155, + 711 + ], + "score": 0.75, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 702, + 214, + 713 + ], + "score": 1.0, + "content": "is drawn from", + "type": "text" + }, + { + "bbox": [ + 214, + 702, + 245, + 713 + ], + "score": 0.91, + "content": "U ( 0 , 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 702, + 506, + 713 + ], + "score": 1.0, + "content": ". Note how this turns red bounding boxes that overlap a lot with a", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 713, + 505, + 724 + ], + "spans": [ + { + "bbox": [ + 106, + 713, + 505, + 724 + ], + "score": 1.0, + "content": "blue bounding box in the ground truth column into a blue bounding box in the data column, which", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 723, + 428, + 735 + ], + "spans": [ + { + "bbox": [ + 105, + 723, + 428, + 735 + ], + "score": 1.0, + "content": "simulates the duplicate proposal that we have to deal with. Best viewed in color.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 7 + } + ], + "index": 4.0 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 116, + 101, + 496, + 648 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 116, + 101, + 496, + 648 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 116, + 101, + 496, + 648 + ], + "spans": [ + { + "bbox": [ + 116, + 101, + 496, + 648 + ], + "score": 0.898, + "type": "image", + "image_path": "2f649731cb7ae201b34fb60357ccbb8c13f0f0e0a6906d1cd4d0372f1be0a82e.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 116, + 101, + 496, + 283.33333333333337 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 116, + 283.33333333333337, + 496, + 465.66666666666674 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 116, + 465.66666666666674, + 496, + 648.0000000000001 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 647, + 506, + 725 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 648, + 505, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 505, + 660 + ], + "score": 1.0, + "content": "Figure 11: Selection of validation images with overlaid bounding boxes, values of the attention", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 658, + 505, + 671 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 505, + 671 + ], + "score": 1.0, + "content": "matrix A, distance matrix D, and the resulting count matrix C. White entries represent values close", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 669, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 669, + 328, + 681 + ], + "score": 1.0, + "content": "to 1, black entries represent values close to 0. The count", + "type": "text" + }, + { + "bbox": [ + 329, + 671, + 334, + 679 + ], + "score": 0.67, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 669, + 505, + 681 + ], + "score": 1.0, + "content": "is the usual square root of the sum over the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 680, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 106, + 680, + 505, + 693 + ], + "score": 1.0, + "content": "elements of C. Notice how particularly in the third example, A clearly contains more rows/columns", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 691, + 506, + 705 + ], + "spans": [ + { + "bbox": [ + 105, + 691, + 506, + 705 + ], + "score": 1.0, + "content": "with high activations than there are actual objects (a sign of overlapping bounding boxes) and the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 703, + 506, + 715 + ], + "spans": [ + { + "bbox": [ + 106, + 703, + 506, + 715 + ], + "score": 1.0, + "content": "counting module successfully removes intra- and inter-object edges to arrive at the correct prediction", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 714, + 456, + 725 + ], + "spans": [ + { + "bbox": [ + 105, + 714, + 446, + 725 + ], + "score": 1.0, + "content": "regardless. The prediction is not necessarily – though often is – the rounded value of", + "type": "text" + }, + { + "bbox": [ + 446, + 716, + 452, + 723 + ], + "score": 0.69, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 714, + 456, + 725 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6 + } + ], + "index": 3.5 + } + ], + "page_idx": 16, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 105, + 82, + 424, + 93 + ], + "lines": [ + { + "bbox": [ + 104, + 79, + 426, + 98 + ], + "spans": [ + { + "bbox": [ + 104, + 79, + 426, + 98 + ], + "score": 1.0, + "content": "E QUALITATIVE EXAMPLES OF INTERMEDIATE ACTIVATIONS", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 116, + 101, + 496, + 648 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 116, + 101, + 496, + 648 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 116, + 101, + 496, + 648 + ], + "spans": [ + { + "bbox": [ + 116, + 101, + 496, + 648 + ], + "score": 0.898, + "type": "image", + "image_path": "2f649731cb7ae201b34fb60357ccbb8c13f0f0e0a6906d1cd4d0372f1be0a82e.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 116, + 101, + 496, + 283.33333333333337 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 116, + 283.33333333333337, + 496, + 465.66666666666674 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 116, + 465.66666666666674, + 496, + 648.0000000000001 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 647, + 506, + 725 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 648, + 505, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 505, + 660 + ], + "score": 1.0, + "content": "Figure 11: Selection of validation images with overlaid bounding boxes, values of the attention", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 658, + 505, + 671 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 505, + 671 + ], + "score": 1.0, + "content": "matrix A, distance matrix D, and the resulting count matrix C. White entries represent values close", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 669, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 669, + 328, + 681 + ], + "score": 1.0, + "content": "to 1, black entries represent values close to 0. The count", + "type": "text" + }, + { + "bbox": [ + 329, + 671, + 334, + 679 + ], + "score": 0.67, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 669, + 505, + 681 + ], + "score": 1.0, + "content": "is the usual square root of the sum over the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 680, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 106, + 680, + 505, + 693 + ], + "score": 1.0, + "content": "elements of C. Notice how particularly in the third example, A clearly contains more rows/columns", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 691, + 506, + 705 + ], + "spans": [ + { + "bbox": [ + 105, + 691, + 506, + 705 + ], + "score": 1.0, + "content": "with high activations than there are actual objects (a sign of overlapping bounding boxes) and the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 703, + 506, + 715 + ], + "spans": [ + { + "bbox": [ + 106, + 703, + 506, + 715 + ], + "score": 1.0, + "content": "counting module successfully removes intra- and inter-object edges to arrive at the correct prediction", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 714, + 456, + 725 + ], + "spans": [ + { + "bbox": [ + 105, + 714, + 446, + 725 + ], + "score": 1.0, + "content": "regardless. The prediction is not necessarily – though often is – the rounded value of", + "type": "text" + }, + { + "bbox": [ + 446, + 716, + 452, + 723 + ], + "score": 0.69, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 714, + 456, + 725 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6 + } + ], + "index": 3.5 + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file